// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::Annotation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Annotation");
        debug_struct.field("name", &self.name);
        debug_struct.field("payload_schema_uri", &self.payload_schema_uri);
        debug_struct.field("payload", &self.payload);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("annotation_source", &self.annotation_source);
        debug_struct.field("labels", &self.labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::AnnotationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnnotationSpec");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ApiAuth {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ApiAuth");
        debug_struct.field("auth_config", &self.auth_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::api_auth::ApiKeyConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ApiKeyConfig");
        debug_struct.field("api_key_secret_version", &self.api_key_secret_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "metadata-service",
    feature = "pipeline-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::Artifact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Artifact");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("state", &self.state);
        debug_struct.field("schema_title", &self.schema_title);
        debug_struct.field("schema_version", &self.schema_version);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("description", &self.description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::BatchPredictionJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchPredictionJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version_id", &self.model_version_id);
        debug_struct.field("unmanaged_container_model", &self.unmanaged_container_model);
        debug_struct.field("input_config", &self.input_config);
        debug_struct.field("instance_config", &self.instance_config);
        debug_struct.field("model_parameters", &self.model_parameters);
        debug_struct.field("output_config", &self.output_config);
        debug_struct.field("dedicated_resources", &self.dedicated_resources);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field(
            "manual_batch_tuning_parameters",
            &self.manual_batch_tuning_parameters,
        );
        debug_struct.field("generate_explanation", &self.generate_explanation);
        debug_struct.field("explanation_spec", &self.explanation_spec);
        debug_struct.field("output_info", &self.output_info);
        debug_struct.field("state", &self.state);
        debug_struct.field("error", &self.error);
        debug_struct.field("partial_failures", &self.partial_failures);
        debug_struct.field("resources_consumed", &self.resources_consumed);
        debug_struct.field("completion_stats", &self.completion_stats);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("disable_container_logging", &self.disable_container_logging);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::batch_prediction_job::InputConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputConfig");
        debug_struct.field("instances_format", &self.instances_format);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::batch_prediction_job::InstanceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InstanceConfig");
        debug_struct.field("instance_type", &self.instance_type);
        debug_struct.field("key_field", &self.key_field);
        debug_struct.field("included_fields", &self.included_fields);
        debug_struct.field("excluded_fields", &self.excluded_fields);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::batch_prediction_job::OutputConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputConfig");
        debug_struct.field("predictions_format", &self.predictions_format);
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::batch_prediction_job::OutputInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputInfo");
        debug_struct.field("bigquery_output_table", &self.bigquery_output_table);
        debug_struct.field("output_location", &self.output_location);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::CachedContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CachedContent");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("model", &self.model);
        debug_struct.field("system_instruction", &self.system_instruction);
        debug_struct.field("contents", &self.contents);
        debug_struct.field("tools", &self.tools);
        debug_struct.field("tool_config", &self.tool_config);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("usage_metadata", &self.usage_metadata);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("expiration", &self.expiration);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::cached_content::UsageMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UsageMetadata");
        debug_struct.field("total_token_count", &self.total_token_count);
        debug_struct.field("text_count", &self.text_count);
        debug_struct.field("image_count", &self.image_count);
        debug_struct.field("video_duration_seconds", &self.video_duration_seconds);
        debug_struct.field("audio_duration_seconds", &self.audio_duration_seconds);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CompletionStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompletionStats");
        debug_struct.field("successful_count", &self.successful_count);
        debug_struct.field("failed_count", &self.failed_count);
        debug_struct.field("incomplete_count", &self.incomplete_count);
        debug_struct.field(
            "successful_forecast_point_count",
            &self.successful_forecast_point_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::Content {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Content");
        debug_struct.field("role", &self.role);
        debug_struct.field("parts", &self.parts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::Part {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Part");
        debug_struct.field("thought", &self.thought);
        debug_struct.field("thought_signature", &self.thought_signature);
        debug_struct.field("data", &self.data);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::Blob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Blob");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::FileData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileData");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("file_uri", &self.file_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::VideoMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VideoMetadata");
        debug_struct.field("start_offset", &self.start_offset);
        debug_struct.field("end_offset", &self.end_offset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::PrebuiltVoiceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PrebuiltVoiceConfig");
        debug_struct.field("voice_name", &self.voice_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::ReplicatedVoiceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReplicatedVoiceConfig");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("voice_sample_audio", &self.voice_sample_audio);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::VoiceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VoiceConfig");
        debug_struct.field("voice_config", &self.voice_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::SpeakerVoiceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpeakerVoiceConfig");
        debug_struct.field("speaker", &self.speaker);
        debug_struct.field("voice_config", &self.voice_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::MultiSpeakerVoiceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MultiSpeakerVoiceConfig");
        debug_struct.field("speaker_voice_configs", &self.speaker_voice_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::SpeechConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpeechConfig");
        debug_struct.field("voice_config", &self.voice_config);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field(
            "multi_speaker_voice_config",
            &self.multi_speaker_voice_config,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::ImageConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImageConfig");
        debug_struct.field("aspect_ratio", &self.aspect_ratio);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::GenerationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerationConfig");
        debug_struct.field("temperature", &self.temperature);
        debug_struct.field("top_p", &self.top_p);
        debug_struct.field("top_k", &self.top_k);
        debug_struct.field("candidate_count", &self.candidate_count);
        debug_struct.field("max_output_tokens", &self.max_output_tokens);
        debug_struct.field("stop_sequences", &self.stop_sequences);
        debug_struct.field("response_logprobs", &self.response_logprobs);
        debug_struct.field("logprobs", &self.logprobs);
        debug_struct.field("presence_penalty", &self.presence_penalty);
        debug_struct.field("frequency_penalty", &self.frequency_penalty);
        debug_struct.field("seed", &self.seed);
        debug_struct.field("response_mime_type", &self.response_mime_type);
        debug_struct.field("response_schema", &self.response_schema);
        debug_struct.field("response_json_schema", &self.response_json_schema);
        debug_struct.field("routing_config", &self.routing_config);
        debug_struct.field("speech_config", &self.speech_config);
        debug_struct.field("thinking_config", &self.thinking_config);
        debug_struct.field("image_config", &self.image_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::generation_config::RoutingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RoutingConfig");
        debug_struct.field("routing_config", &self.routing_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::generation_config::routing_config::AutoRoutingMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutoRoutingMode");
        debug_struct.field("model_routing_preference", &self.model_routing_preference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::generation_config::routing_config::ManualRoutingMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ManualRoutingMode");
        debug_struct.field("model_name", &self.model_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::generation_config::ThinkingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ThinkingConfig");
        debug_struct.field("include_thoughts", &self.include_thoughts);
        debug_struct.field("thinking_budget", &self.thinking_budget);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::SafetySetting {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetySetting");
        debug_struct.field("category", &self.category);
        debug_struct.field("threshold", &self.threshold);
        debug_struct.field("method", &self.method);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::SafetyRating {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyRating");
        debug_struct.field("category", &self.category);
        debug_struct.field("probability", &self.probability);
        debug_struct.field("probability_score", &self.probability_score);
        debug_struct.field("severity", &self.severity);
        debug_struct.field("severity_score", &self.severity_score);
        debug_struct.field("blocked", &self.blocked);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::CitationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CitationMetadata");
        debug_struct.field("citations", &self.citations);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::Citation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Citation");
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("license", &self.license);
        debug_struct.field("publication_date", &self.publication_date);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::Candidate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Candidate");
        debug_struct.field("index", &self.index);
        debug_struct.field("content", &self.content);
        debug_struct.field("score", &self.score);
        debug_struct.field("avg_logprobs", &self.avg_logprobs);
        debug_struct.field("logprobs_result", &self.logprobs_result);
        debug_struct.field("finish_reason", &self.finish_reason);
        debug_struct.field("safety_ratings", &self.safety_ratings);
        debug_struct.field("finish_message", &self.finish_message);
        debug_struct.field("citation_metadata", &self.citation_metadata);
        debug_struct.field("grounding_metadata", &self.grounding_metadata);
        debug_struct.field("url_context_metadata", &self.url_context_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::UrlContextMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UrlContextMetadata");
        debug_struct.field("url_metadata", &self.url_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::UrlMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UrlMetadata");
        debug_struct.field("retrieved_url", &self.retrieved_url);
        debug_struct.field("url_retrieval_status", &self.url_retrieval_status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::LogprobsResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LogprobsResult");
        debug_struct.field("top_candidates", &self.top_candidates);
        debug_struct.field("chosen_candidates", &self.chosen_candidates);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::logprobs_result::Candidate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Candidate");
        debug_struct.field("token", &self.token);
        debug_struct.field("token_id", &self.token_id);
        debug_struct.field("log_probability", &self.log_probability);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::logprobs_result::TopCandidates {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TopCandidates");
        debug_struct.field("candidates", &self.candidates);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::Segment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Segment");
        debug_struct.field("part_index", &self.part_index);
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("text", &self.text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::GroundingChunk {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingChunk");
        debug_struct.field("chunk_type", &self.chunk_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::grounding_chunk::Web {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Web");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::grounding_chunk::RetrievedContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RetrievedContext");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("text", &self.text);
        debug_struct.field("document_name", &self.document_name);
        debug_struct.field("context_details", &self.context_details);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::grounding_chunk::Maps {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Maps");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("text", &self.text);
        debug_struct.field("place_id", &self.place_id);
        debug_struct.field("place_answer_sources", &self.place_answer_sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::grounding_chunk::maps::PlaceAnswerSources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PlaceAnswerSources");
        debug_struct.field("review_snippets", &self.review_snippets);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::grounding_chunk::maps::place_answer_sources::ReviewSnippet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReviewSnippet");
        debug_struct.field("review_id", &self.review_id);
        debug_struct.field("google_maps_uri", &self.google_maps_uri);
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::GroundingSupport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingSupport");
        debug_struct.field("segment", &self.segment);
        debug_struct.field("grounding_chunk_indices", &self.grounding_chunk_indices);
        debug_struct.field("confidence_scores", &self.confidence_scores);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::GroundingMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingMetadata");
        debug_struct.field("web_search_queries", &self.web_search_queries);
        debug_struct.field("search_entry_point", &self.search_entry_point);
        debug_struct.field("grounding_chunks", &self.grounding_chunks);
        debug_struct.field("grounding_supports", &self.grounding_supports);
        debug_struct.field("retrieval_metadata", &self.retrieval_metadata);
        debug_struct.field(
            "google_maps_widget_context_token",
            &self.google_maps_widget_context_token,
        );
        debug_struct.field("source_flagging_uris", &self.source_flagging_uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::grounding_metadata::SourceFlaggingUri {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SourceFlaggingUri");
        debug_struct.field("source_id", &self.source_id);
        debug_struct.field("flag_content_uri", &self.flag_content_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::SearchEntryPoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchEntryPoint");
        debug_struct.field("rendered_content", &self.rendered_content);
        debug_struct.field("sdk_blob", &self.sdk_blob);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::RetrievalMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RetrievalMetadata");
        debug_struct.field(
            "google_search_dynamic_retrieval_score",
            &self.google_search_dynamic_retrieval_score,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ModelArmorConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelArmorConfig");
        debug_struct.field("prompt_template_name", &self.prompt_template_name);
        debug_struct.field("response_template_name", &self.response_template_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "llm-utility-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::ModalityTokenCount {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModalityTokenCount");
        debug_struct.field("modality", &self.modality);
        debug_struct.field("token_count", &self.token_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "metadata-service",
    feature = "pipeline-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::Context {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Context");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("parent_contexts", &self.parent_contexts);
        debug_struct.field("schema_title", &self.schema_title);
        debug_struct.field("schema_version", &self.schema_version);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("description", &self.description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CustomJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("job_spec", &self.job_spec);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("error", &self.error);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("web_access_uris", &self.web_access_uris);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CustomJobSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomJobSpec");
        debug_struct.field("persistent_resource_id", &self.persistent_resource_id);
        debug_struct.field("worker_pool_specs", &self.worker_pool_specs);
        debug_struct.field("scheduling", &self.scheduling);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("network", &self.network);
        debug_struct.field("reserved_ip_ranges", &self.reserved_ip_ranges);
        debug_struct.field("psc_interface_config", &self.psc_interface_config);
        debug_struct.field("base_output_directory", &self.base_output_directory);
        debug_struct.field(
            "protected_artifact_location_id",
            &self.protected_artifact_location_id,
        );
        debug_struct.field("tensorboard", &self.tensorboard);
        debug_struct.field("enable_web_access", &self.enable_web_access);
        debug_struct.field("enable_dashboard_access", &self.enable_dashboard_access);
        debug_struct.field("experiment", &self.experiment);
        debug_struct.field("experiment_run", &self.experiment_run);
        debug_struct.field("models", &self.models);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::WorkerPoolSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WorkerPoolSpec");
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("replica_count", &self.replica_count);
        debug_struct.field("nfs_mounts", &self.nfs_mounts);
        debug_struct.field("disk_spec", &self.disk_spec);
        debug_struct.field("task", &self.task);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ContainerSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContainerSpec");
        debug_struct.field("image_uri", &self.image_uri);
        debug_struct.field("command", &self.command);
        debug_struct.field("args", &self.args);
        debug_struct.field("env", &self.env);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::PythonPackageSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PythonPackageSpec");
        debug_struct.field("executor_image_uri", &self.executor_image_uri);
        debug_struct.field("package_uris", &self.package_uris);
        debug_struct.field("python_module", &self.python_module);
        debug_struct.field("args", &self.args);
        debug_struct.field("env", &self.env);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::Scheduling {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Scheduling");
        debug_struct.field("timeout", &self.timeout);
        debug_struct.field(
            "restart_job_on_worker_restart",
            &self.restart_job_on_worker_restart,
        );
        debug_struct.field("strategy", &self.strategy);
        debug_struct.field("disable_retries", &self.disable_retries);
        debug_struct.field("max_wait_duration", &self.max_wait_duration);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-foundry-service")]
impl std::fmt::Debug for super::GenerateSyntheticDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateSyntheticDataRequest");
        debug_struct.field("location", &self.location);
        debug_struct.field("count", &self.count);
        debug_struct.field("output_field_specs", &self.output_field_specs);
        debug_struct.field("examples", &self.examples);
        debug_struct.field("strategy", &self.strategy);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-foundry-service")]
impl std::fmt::Debug for super::SyntheticField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SyntheticField");
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-foundry-service")]
impl std::fmt::Debug for super::SyntheticExample {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SyntheticExample");
        debug_struct.field("fields", &self.fields);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-foundry-service")]
impl std::fmt::Debug for super::OutputFieldSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputFieldSpec");
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("guidance", &self.guidance);
        debug_struct.field("field_type", &self.field_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-foundry-service")]
impl std::fmt::Debug for super::TaskDescriptionStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TaskDescriptionStrategy");
        debug_struct.field("task_description", &self.task_description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-foundry-service")]
impl std::fmt::Debug for super::GenerateSyntheticDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateSyntheticDataResponse");
        debug_struct.field("synthetic_examples", &self.synthetic_examples);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::DataItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataItem");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("payload", &self.payload);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DataLabelingJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataLabelingJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("datasets", &self.datasets);
        debug_struct.field("annotation_labels", &self.annotation_labels);
        debug_struct.field("labeler_count", &self.labeler_count);
        debug_struct.field("instruction_uri", &self.instruction_uri);
        debug_struct.field("inputs_schema_uri", &self.inputs_schema_uri);
        debug_struct.field("inputs", &self.inputs);
        debug_struct.field("state", &self.state);
        debug_struct.field("labeling_progress", &self.labeling_progress);
        debug_struct.field("current_spend", &self.current_spend);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("error", &self.error);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("specialist_pools", &self.specialist_pools);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("active_learning_config", &self.active_learning_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ActiveLearningConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ActiveLearningConfig");
        debug_struct.field("sample_config", &self.sample_config);
        debug_struct.field("training_config", &self.training_config);
        debug_struct.field("human_labeling_budget", &self.human_labeling_budget);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::SampleConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SampleConfig");
        debug_struct.field("sample_strategy", &self.sample_strategy);
        debug_struct.field("initial_batch_sample_size", &self.initial_batch_sample_size);
        debug_struct.field(
            "following_batch_sample_size",
            &self.following_batch_sample_size,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::TrainingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainingConfig");
        debug_struct.field(
            "timeout_training_milli_hours",
            &self.timeout_training_milli_hours,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::Dataset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Dataset");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("metadata_schema_uri", &self.metadata_schema_uri);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("data_item_count", &self.data_item_count);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("saved_queries", &self.saved_queries);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("metadata_artifact", &self.metadata_artifact);
        debug_struct.field("model_reference", &self.model_reference);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ImportDataConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDataConfig");
        debug_struct.field("data_item_labels", &self.data_item_labels);
        debug_struct.field("annotation_labels", &self.annotation_labels);
        debug_struct.field("import_schema_uri", &self.import_schema_uri);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ExportDataConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportDataConfig");
        debug_struct.field("annotations_filter", &self.annotations_filter);
        debug_struct.field("saved_query_id", &self.saved_query_id);
        debug_struct.field("annotation_schema_uri", &self.annotation_schema_uri);
        debug_struct.field("export_use", &self.export_use);
        debug_struct.field("destination", &self.destination);
        debug_struct.field("split", &self.split);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ExportFractionSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportFractionSplit");
        debug_struct.field("training_fraction", &self.training_fraction);
        debug_struct.field("validation_fraction", &self.validation_fraction);
        debug_struct.field("test_fraction", &self.test_fraction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ExportFilterSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportFilterSplit");
        debug_struct.field("training_filter", &self.training_filter);
        debug_struct.field("validation_filter", &self.validation_filter);
        debug_struct.field("test_filter", &self.test_filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::CreateDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDatasetRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("dataset", &self.dataset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::CreateDatasetOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDatasetOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::GetDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDatasetRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::UpdateDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDatasetRequest");
        debug_struct.field("dataset", &self.dataset);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::UpdateDatasetVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDatasetVersionRequest");
        debug_struct.field("dataset_version", &self.dataset_version);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListDatasetsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatasetsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListDatasetsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatasetsResponse");
        debug_struct.field("datasets", &self.datasets);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::DeleteDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDatasetRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ImportDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDataRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("import_configs", &self.import_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ImportDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDataResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ImportDataOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDataOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ExportDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportDataRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("export_config", &self.export_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ExportDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportDataResponse");
        debug_struct.field("exported_files", &self.exported_files);
        debug_struct.field("data_stats", &self.data_stats);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ExportDataOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportDataOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("gcs_output_directory", &self.gcs_output_directory);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::CreateDatasetVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDatasetVersionRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("dataset_version", &self.dataset_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::CreateDatasetVersionOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDatasetVersionOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::DeleteDatasetVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDatasetVersionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::GetDatasetVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDatasetVersionRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListDatasetVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatasetVersionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListDatasetVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatasetVersionsResponse");
        debug_struct.field("dataset_versions", &self.dataset_versions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::RestoreDatasetVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RestoreDatasetVersionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::RestoreDatasetVersionOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RestoreDatasetVersionOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListDataItemsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDataItemsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListDataItemsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDataItemsResponse");
        debug_struct.field("data_items", &self.data_items);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::SearchDataItemsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchDataItemsRequest");
        debug_struct.field("dataset", &self.dataset);
        debug_struct.field("saved_query", &self.saved_query);
        debug_struct.field("data_labeling_job", &self.data_labeling_job);
        debug_struct.field("data_item_filter", &self.data_item_filter);
        debug_struct.field("annotations_filter", &self.annotations_filter);
        debug_struct.field("annotation_filters", &self.annotation_filters);
        debug_struct.field("field_mask", &self.field_mask);
        debug_struct.field("annotations_limit", &self.annotations_limit);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order", &self.order);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::search_data_items_request::OrderByAnnotation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OrderByAnnotation");
        debug_struct.field("saved_query", &self.saved_query);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::SearchDataItemsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchDataItemsResponse");
        debug_struct.field("data_item_views", &self.data_item_views);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::DataItemView {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataItemView");
        debug_struct.field("data_item", &self.data_item);
        debug_struct.field("annotations", &self.annotations);
        debug_struct.field("has_truncated_annotations", &self.has_truncated_annotations);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListSavedQueriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSavedQueriesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListSavedQueriesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSavedQueriesResponse");
        debug_struct.field("saved_queries", &self.saved_queries);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::DeleteSavedQueryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSavedQueryRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::GetAnnotationSpecRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetAnnotationSpecRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListAnnotationsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAnnotationsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::ListAnnotationsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAnnotationsResponse");
        debug_struct.field("annotations", &self.annotations);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::DatasetVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DatasetVersion");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("big_query_dataset_name", &self.big_query_dataset_name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("model_reference", &self.model_reference);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::DeployedIndexRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployedIndexRef");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("deployed_index_id", &self.deployed_index_id);
        debug_struct.field("display_name", &self.display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::DeployedModelRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployedModelRef");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::DeploymentResourcePool {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeploymentResourcePool");
        debug_struct.field("name", &self.name);
        debug_struct.field("dedicated_resources", &self.dedicated_resources);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("disable_container_logging", &self.disable_container_logging);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::CreateDeploymentResourcePoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDeploymentResourcePoolRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("deployment_resource_pool", &self.deployment_resource_pool);
        debug_struct.field(
            "deployment_resource_pool_id",
            &self.deployment_resource_pool_id,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::CreateDeploymentResourcePoolOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDeploymentResourcePoolOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::GetDeploymentResourcePoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDeploymentResourcePoolRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::ListDeploymentResourcePoolsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDeploymentResourcePoolsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::ListDeploymentResourcePoolsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDeploymentResourcePoolsResponse");
        debug_struct.field("deployment_resource_pools", &self.deployment_resource_pools);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::UpdateDeploymentResourcePoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDeploymentResourcePoolRequest");
        debug_struct.field("deployment_resource_pool", &self.deployment_resource_pool);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::UpdateDeploymentResourcePoolOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDeploymentResourcePoolOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::DeleteDeploymentResourcePoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDeploymentResourcePoolRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::QueryDeployedModelsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryDeployedModelsRequest");
        debug_struct.field("deployment_resource_pool", &self.deployment_resource_pool);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "deployment-resource-pool-service")]
impl std::fmt::Debug for super::QueryDeployedModelsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryDeployedModelsResponse");
        debug_struct.field("deployed_models", &self.deployed_models);
        debug_struct.field("next_page_token", &self.next_page_token);
        debug_struct.field("deployed_model_refs", &self.deployed_model_refs);
        debug_struct.field(
            "total_deployed_model_count",
            &self.total_deployed_model_count,
        );
        debug_struct.field("total_endpoint_count", &self.total_endpoint_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "feature-online-store-admin-service",
    feature = "featurestore-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "index-endpoint-service",
    feature = "index-service",
    feature = "job-service",
    feature = "metadata-service",
    feature = "model-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
    feature = "tensorboard-service",
    feature = "vertex-rag-data-service",
))]
impl std::fmt::Debug for super::EncryptionSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EncryptionSpec");
        debug_struct.field("kms_key_name", &self.kms_key_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::Endpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Endpoint");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("deployed_models", &self.deployed_models);
        debug_struct.field("traffic_split", &self.traffic_split);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("network", &self.network);
        debug_struct.field(
            "enable_private_service_connect",
            &self.enable_private_service_connect,
        );
        debug_struct.field(
            "private_service_connect_config",
            &self.private_service_connect_config,
        );
        debug_struct.field(
            "model_deployment_monitoring_job",
            &self.model_deployment_monitoring_job,
        );
        debug_struct.field(
            "predict_request_response_logging_config",
            &self.predict_request_response_logging_config,
        );
        debug_struct.field(
            "dedicated_endpoint_enabled",
            &self.dedicated_endpoint_enabled,
        );
        debug_struct.field("dedicated_endpoint_dns", &self.dedicated_endpoint_dns);
        debug_struct.field("client_connection_config", &self.client_connection_config);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        debug_struct.field(
            "gen_ai_advanced_features_config",
            &self.gen_ai_advanced_features_config,
        );
        debug_struct.field(
            "private_model_server_enabled",
            &self.private_model_server_enabled,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::DeployedModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployedModel");
        debug_struct.field("id", &self.id);
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version_id", &self.model_version_id);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("explanation_spec", &self.explanation_spec);
        debug_struct.field("disable_explanations", &self.disable_explanations);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("disable_container_logging", &self.disable_container_logging);
        debug_struct.field("enable_access_logging", &self.enable_access_logging);
        debug_struct.field("private_endpoints", &self.private_endpoints);
        debug_struct.field("faster_deployment_config", &self.faster_deployment_config);
        debug_struct.field("status", &self.status);
        debug_struct.field("system_labels", &self.system_labels);
        debug_struct.field("checkpoint_id", &self.checkpoint_id);
        debug_struct.field("speculative_decoding_spec", &self.speculative_decoding_spec);
        debug_struct.field("prediction_resources", &self.prediction_resources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::deployed_model::Status {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Status");
        debug_struct.field("message", &self.message);
        debug_struct.field("last_update_time", &self.last_update_time);
        debug_struct.field("available_replica_count", &self.available_replica_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::PrivateEndpoints {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PrivateEndpoints");
        debug_struct.field("predict_http_uri", &self.predict_http_uri);
        debug_struct.field("explain_http_uri", &self.explain_http_uri);
        debug_struct.field("health_http_uri", &self.health_http_uri);
        debug_struct.field("service_attachment", &self.service_attachment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::PredictRequestResponseLoggingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PredictRequestResponseLoggingConfig");
        debug_struct.field("enabled", &self.enabled);
        debug_struct.field("sampling_rate", &self.sampling_rate);
        debug_struct.field("bigquery_destination", &self.bigquery_destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::ClientConnectionConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ClientConnectionConfig");
        debug_struct.field("inference_timeout", &self.inference_timeout);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::FasterDeploymentConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FasterDeploymentConfig");
        debug_struct.field("fast_tryout_enabled", &self.fast_tryout_enabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::GenAiAdvancedFeaturesConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenAiAdvancedFeaturesConfig");
        debug_struct.field("rag_config", &self.rag_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::gen_ai_advanced_features_config::RagConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagConfig");
        debug_struct.field("enable_rag", &self.enable_rag);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::SpeculativeDecodingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpeculativeDecodingSpec");
        debug_struct.field("speculative_token_count", &self.speculative_token_count);
        debug_struct.field("speculation", &self.speculation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::speculative_decoding_spec::DraftModelSpeculation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DraftModelSpeculation");
        debug_struct.field("draft_model", &self.draft_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
))]
impl std::fmt::Debug for super::speculative_decoding_spec::NgramSpeculation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NgramSpeculation");
        debug_struct.field("ngram_size", &self.ngram_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::CreateEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEndpointRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("endpoint_id", &self.endpoint_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::CreateEndpointOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEndpointOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("deployment_stage", &self.deployment_stage);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::GetEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEndpointRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::ListEndpointsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEndpointsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::ListEndpointsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEndpointsResponse");
        debug_struct.field("endpoints", &self.endpoints);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::UpdateEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEndpointRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::UpdateEndpointLongRunningRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEndpointLongRunningRequest");
        debug_struct.field("endpoint", &self.endpoint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::UpdateEndpointOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEndpointOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::DeleteEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteEndpointRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::DeployModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployModelRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("deployed_model", &self.deployed_model);
        debug_struct.field("traffic_split", &self.traffic_split);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::DeployModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployModelResponse");
        debug_struct.field("deployed_model", &self.deployed_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::DeployModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("deployment_stage", &self.deployment_stage);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::UndeployModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployModelRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        debug_struct.field("traffic_split", &self.traffic_split);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::UndeployModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployModelResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::UndeployModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::MutateDeployedModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutateDeployedModelRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("deployed_model", &self.deployed_model);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::MutateDeployedModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutateDeployedModelResponse");
        debug_struct.field("deployed_model", &self.deployed_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "endpoint-service")]
impl std::fmt::Debug for super::MutateDeployedModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutateDeployedModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::EntityType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityType");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("monitoring_config", &self.monitoring_config);
        debug_struct.field("offline_storage_ttl_days", &self.offline_storage_ttl_days);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "notebook-service",
    feature = "pipeline-service",
    feature = "reasoning-engine-service",
))]
impl std::fmt::Debug for super::EnvVar {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnvVar");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::SecretRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SecretRef");
        debug_struct.field("secret", &self.secret);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::SecretEnvVar {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SecretEnvVar");
        debug_struct.field("name", &self.name);
        debug_struct.field("secret_ref", &self.secret_ref);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::EvaluatedAnnotation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EvaluatedAnnotation");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("predictions", &self.predictions);
        debug_struct.field("ground_truths", &self.ground_truths);
        debug_struct.field("data_item_payload", &self.data_item_payload);
        debug_struct.field(
            "evaluated_data_item_view_id",
            &self.evaluated_data_item_view_id,
        );
        debug_struct.field("explanations", &self.explanations);
        debug_struct.field(
            "error_analysis_annotations",
            &self.error_analysis_annotations,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::EvaluatedAnnotationExplanation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EvaluatedAnnotationExplanation");
        debug_struct.field("explanation_type", &self.explanation_type);
        debug_struct.field("explanation", &self.explanation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ErrorAnalysisAnnotation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ErrorAnalysisAnnotation");
        debug_struct.field("attributed_items", &self.attributed_items);
        debug_struct.field("query_type", &self.query_type);
        debug_struct.field("outlier_score", &self.outlier_score);
        debug_struct.field("outlier_threshold", &self.outlier_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::error_analysis_annotation::AttributedItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AttributedItem");
        debug_struct.field("annotation_resource_name", &self.annotation_resource_name);
        debug_struct.field("distance", &self.distance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::EvaluateInstancesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EvaluateInstancesRequest");
        debug_struct.field("location", &self.location);
        debug_struct.field("metric_inputs", &self.metric_inputs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::EvaluateInstancesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EvaluateInstancesResponse");
        debug_struct.field("evaluation_results", &self.evaluation_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ExactMatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExactMatchInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ExactMatchInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExactMatchInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ExactMatchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExactMatchSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ExactMatchResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExactMatchResults");
        debug_struct.field("exact_match_metric_values", &self.exact_match_metric_values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ExactMatchMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExactMatchMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::BleuInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BleuInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::BleuInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BleuInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::BleuSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BleuSpec");
        debug_struct.field("use_effective_order", &self.use_effective_order);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::BleuResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BleuResults");
        debug_struct.field("bleu_metric_values", &self.bleu_metric_values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::BleuMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BleuMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::RougeInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RougeInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::RougeInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RougeInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::RougeSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RougeSpec");
        debug_struct.field("rouge_type", &self.rouge_type);
        debug_struct.field("use_stemmer", &self.use_stemmer);
        debug_struct.field("split_summaries", &self.split_summaries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::RougeResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RougeResults");
        debug_struct.field("rouge_metric_values", &self.rouge_metric_values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::RougeMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RougeMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CoherenceInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CoherenceInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CoherenceInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CoherenceInstance");
        debug_struct.field("prediction", &self.prediction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CoherenceSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CoherenceSpec");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CoherenceResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CoherenceResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FluencyInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FluencyInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FluencyInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FluencyInstance");
        debug_struct.field("prediction", &self.prediction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FluencySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FluencySpec");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FluencyResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FluencyResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SafetyInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SafetyInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyInstance");
        debug_struct.field("prediction", &self.prediction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SafetySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetySpec");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SafetyResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::GroundednessInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundednessInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::GroundednessInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundednessInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("context", &self.context);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::GroundednessSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundednessSpec");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::GroundednessResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundednessResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FulfillmentInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FulfillmentInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FulfillmentInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FulfillmentInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FulfillmentSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FulfillmentSpec");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::FulfillmentResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FulfillmentResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationQualityInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationQualityInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationQualityInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationQualityInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationQualitySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationQualitySpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationQualityResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationQualityResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseSummarizationQualityInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseSummarizationQualityInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseSummarizationQualityInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseSummarizationQualityInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("baseline_prediction", &self.baseline_prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseSummarizationQualitySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseSummarizationQualitySpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseSummarizationQualityResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseSummarizationQualityResult");
        debug_struct.field("pairwise_choice", &self.pairwise_choice);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationHelpfulnessInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationHelpfulnessInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationHelpfulnessInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationHelpfulnessInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationHelpfulnessSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationHelpfulnessSpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationHelpfulnessResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationHelpfulnessResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationVerbosityInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationVerbosityInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationVerbosityInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationVerbosityInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationVerbositySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationVerbositySpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::SummarizationVerbosityResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationVerbosityResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringQualityInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringQualityInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringQualityInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringQualityInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringQualitySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringQualitySpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringQualityResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringQualityResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseQuestionAnsweringQualityInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseQuestionAnsweringQualityInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseQuestionAnsweringQualityInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseQuestionAnsweringQualityInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("baseline_prediction", &self.baseline_prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseQuestionAnsweringQualitySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseQuestionAnsweringQualitySpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseQuestionAnsweringQualityResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseQuestionAnsweringQualityResult");
        debug_struct.field("pairwise_choice", &self.pairwise_choice);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringRelevanceInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringRelevanceInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringRelevanceInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringRelevanceInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringRelevanceSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringRelevanceSpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringRelevanceResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringRelevanceResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringHelpfulnessInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringHelpfulnessInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringHelpfulnessInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringHelpfulnessInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringHelpfulnessSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringHelpfulnessSpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringHelpfulnessResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringHelpfulnessResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringCorrectnessInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringCorrectnessInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringCorrectnessInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringCorrectnessInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("context", &self.context);
        debug_struct.field("instruction", &self.instruction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringCorrectnessSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringCorrectnessSpec");
        debug_struct.field("use_reference", &self.use_reference);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::QuestionAnsweringCorrectnessResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuestionAnsweringCorrectnessResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PointwiseMetricInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PointwiseMetricInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PointwiseMetricInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PointwiseMetricInstance");
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PointwiseMetricSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PointwiseMetricSpec");
        debug_struct.field("metric_prompt_template", &self.metric_prompt_template);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PointwiseMetricResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PointwiseMetricResult");
        debug_struct.field("score", &self.score);
        debug_struct.field("explanation", &self.explanation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseMetricInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseMetricInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseMetricInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseMetricInstance");
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseMetricSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseMetricSpec");
        debug_struct.field("metric_prompt_template", &self.metric_prompt_template);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::PairwiseMetricResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PairwiseMetricResult");
        debug_struct.field("pairwise_choice", &self.pairwise_choice);
        debug_struct.field("explanation", &self.explanation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolCallValidInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolCallValidInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolCallValidSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolCallValidSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolCallValidInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolCallValidInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolCallValidResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolCallValidResults");
        debug_struct.field(
            "tool_call_valid_metric_values",
            &self.tool_call_valid_metric_values,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolCallValidMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolCallValidMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolNameMatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolNameMatchInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolNameMatchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolNameMatchSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolNameMatchInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolNameMatchInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolNameMatchResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolNameMatchResults");
        debug_struct.field(
            "tool_name_match_metric_values",
            &self.tool_name_match_metric_values,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolNameMatchMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolNameMatchMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKeyMatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKeyMatchInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKeyMatchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKeyMatchSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKeyMatchInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKeyMatchInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKeyMatchResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKeyMatchResults");
        debug_struct.field(
            "tool_parameter_key_match_metric_values",
            &self.tool_parameter_key_match_metric_values,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKeyMatchMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKeyMatchMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKVMatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKVMatchInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instances", &self.instances);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKVMatchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKVMatchSpec");
        debug_struct.field("use_strict_string_match", &self.use_strict_string_match);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKVMatchInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKVMatchInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKVMatchResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKVMatchResults");
        debug_struct.field(
            "tool_parameter_kv_match_metric_values",
            &self.tool_parameter_kv_match_metric_values,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::ToolParameterKVMatchMetricValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolParameterKVMatchMetricValue");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CometInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CometInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CometSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CometSpec");
        debug_struct.field("version", &self.version);
        debug_struct.field("source_language", &self.source_language);
        debug_struct.field("target_language", &self.target_language);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CometInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CometInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::CometResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CometResult");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::MetricxInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetricxInput");
        debug_struct.field("metric_spec", &self.metric_spec);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::MetricxSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetricxSpec");
        debug_struct.field("version", &self.version);
        debug_struct.field("source_language", &self.source_language);
        debug_struct.field("target_language", &self.target_language);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::MetricxInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetricxInstance");
        debug_struct.field("prediction", &self.prediction);
        debug_struct.field("reference", &self.reference);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "evaluation-service")]
impl std::fmt::Debug for super::MetricxResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetricxResult");
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::Event {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Event");
        debug_struct.field("artifact", &self.artifact);
        debug_struct.field("execution", &self.execution);
        debug_struct.field("event_time", &self.event_time);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("labels", &self.labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "metadata-service",
    feature = "pipeline-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::Execution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Execution");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("state", &self.state);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("schema_title", &self.schema_title);
        debug_struct.field("schema_version", &self.schema_version);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("description", &self.description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "model-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::Explanation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Explanation");
        debug_struct.field("attributions", &self.attributions);
        debug_struct.field("neighbors", &self.neighbors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ModelExplanation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelExplanation");
        debug_struct.field("mean_attributions", &self.mean_attributions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "model-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::Attribution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Attribution");
        debug_struct.field("baseline_output_value", &self.baseline_output_value);
        debug_struct.field("instance_output_value", &self.instance_output_value);
        debug_struct.field("feature_attributions", &self.feature_attributions);
        debug_struct.field("output_index", &self.output_index);
        debug_struct.field("output_display_name", &self.output_display_name);
        debug_struct.field("approximation_error", &self.approximation_error);
        debug_struct.field("output_name", &self.output_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "model-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::Neighbor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Neighbor");
        debug_struct.field("neighbor_id", &self.neighbor_id);
        debug_struct.field("neighbor_distance", &self.neighbor_distance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::ExplanationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationSpec");
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::ExplanationParameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationParameters");
        debug_struct.field("top_k", &self.top_k);
        debug_struct.field("output_indices", &self.output_indices);
        debug_struct.field("method", &self.method);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::SampledShapleyAttribution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SampledShapleyAttribution");
        debug_struct.field("path_count", &self.path_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::IntegratedGradientsAttribution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IntegratedGradientsAttribution");
        debug_struct.field("step_count", &self.step_count);
        debug_struct.field("smooth_grad_config", &self.smooth_grad_config);
        debug_struct.field("blur_baseline_config", &self.blur_baseline_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::XraiAttribution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("XraiAttribution");
        debug_struct.field("step_count", &self.step_count);
        debug_struct.field("smooth_grad_config", &self.smooth_grad_config);
        debug_struct.field("blur_baseline_config", &self.blur_baseline_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::SmoothGradConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SmoothGradConfig");
        debug_struct.field("noisy_sample_count", &self.noisy_sample_count);
        debug_struct.field("gradient_noise_sigma", &self.gradient_noise_sigma);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::FeatureNoiseSigma {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureNoiseSigma");
        debug_struct.field("noise_sigma", &self.noise_sigma);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::feature_noise_sigma::NoiseSigmaForFeature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NoiseSigmaForFeature");
        debug_struct.field("name", &self.name);
        debug_struct.field("sigma", &self.sigma);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::BlurBaselineConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BlurBaselineConfig");
        debug_struct.field("max_blur_sigma", &self.max_blur_sigma);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::Examples {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Examples");
        debug_struct.field("neighbor_count", &self.neighbor_count);
        debug_struct.field("source", &self.source);
        debug_struct.field("config", &self.config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::examples::ExampleGcsSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExampleGcsSource");
        debug_struct.field("data_format", &self.data_format);
        debug_struct.field("gcs_source", &self.gcs_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::Presets {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Presets");
        debug_struct.field("query", &self.query);
        debug_struct.field("modality", &self.modality);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ExplanationSpecOverride {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationSpecOverride");
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("examples_override", &self.examples_override);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ExplanationMetadataOverride {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationMetadataOverride");
        debug_struct.field("inputs", &self.inputs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::explanation_metadata_override::InputMetadataOverride {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputMetadataOverride");
        debug_struct.field("input_baselines", &self.input_baselines);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ExamplesOverride {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExamplesOverride");
        debug_struct.field("neighbor_count", &self.neighbor_count);
        debug_struct.field("crowding_count", &self.crowding_count);
        debug_struct.field("restrictions", &self.restrictions);
        debug_struct.field("return_embeddings", &self.return_embeddings);
        debug_struct.field("data_format", &self.data_format);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ExamplesRestrictionsNamespace {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExamplesRestrictionsNamespace");
        debug_struct.field("namespace_name", &self.namespace_name);
        debug_struct.field("allow", &self.allow);
        debug_struct.field("deny", &self.deny);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::ExplanationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationMetadata");
        debug_struct.field("inputs", &self.inputs);
        debug_struct.field("outputs", &self.outputs);
        debug_struct.field(
            "feature_attributions_schema_uri",
            &self.feature_attributions_schema_uri,
        );
        debug_struct.field("latent_space_source", &self.latent_space_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::explanation_metadata::InputMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputMetadata");
        debug_struct.field("input_baselines", &self.input_baselines);
        debug_struct.field("input_tensor_name", &self.input_tensor_name);
        debug_struct.field("encoding", &self.encoding);
        debug_struct.field("modality", &self.modality);
        debug_struct.field("feature_value_domain", &self.feature_value_domain);
        debug_struct.field("indices_tensor_name", &self.indices_tensor_name);
        debug_struct.field("dense_shape_tensor_name", &self.dense_shape_tensor_name);
        debug_struct.field("index_feature_mapping", &self.index_feature_mapping);
        debug_struct.field("encoded_tensor_name", &self.encoded_tensor_name);
        debug_struct.field("encoded_baselines", &self.encoded_baselines);
        debug_struct.field("visualization", &self.visualization);
        debug_struct.field("group_name", &self.group_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::explanation_metadata::input_metadata::FeatureValueDomain {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureValueDomain");
        debug_struct.field("min_value", &self.min_value);
        debug_struct.field("max_value", &self.max_value);
        debug_struct.field("original_mean", &self.original_mean);
        debug_struct.field("original_stddev", &self.original_stddev);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::explanation_metadata::input_metadata::Visualization {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Visualization");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("polarity", &self.polarity);
        debug_struct.field("color_map", &self.color_map);
        debug_struct.field("clip_percent_upperbound", &self.clip_percent_upperbound);
        debug_struct.field("clip_percent_lowerbound", &self.clip_percent_lowerbound);
        debug_struct.field("overlay_type", &self.overlay_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::explanation_metadata::OutputMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputMetadata");
        debug_struct.field("output_tensor_name", &self.output_tensor_name);
        debug_struct.field("display_name_mapping", &self.display_name_mapping);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::Feature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Feature");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("value_type", &self.value_type);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("disable_monitoring", &self.disable_monitoring);
        debug_struct.field(
            "monitoring_stats_anomalies",
            &self.monitoring_stats_anomalies,
        );
        debug_struct.field("version_column_name", &self.version_column_name);
        debug_struct.field("point_of_contact", &self.point_of_contact);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::feature::MonitoringStatsAnomaly {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MonitoringStatsAnomaly");
        debug_struct.field("objective", &self.objective);
        debug_struct.field("feature_stats_anomaly", &self.feature_stats_anomaly);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::FeatureGroup {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureGroup");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("description", &self.description);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::feature_group::BigQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigQuery");
        debug_struct.field("big_query_source", &self.big_query_source);
        debug_struct.field("entity_id_columns", &self.entity_id_columns);
        debug_struct.field("static_data_source", &self.static_data_source);
        debug_struct.field("time_series", &self.time_series);
        debug_struct.field("dense", &self.dense);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::feature_group::big_query::TimeSeries {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TimeSeries");
        debug_struct.field("timestamp_column", &self.timestamp_column);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-registry-service",
    feature = "featurestore-service",
    feature = "job-service",
))]
impl std::fmt::Debug for super::FeatureStatsAnomaly {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureStatsAnomaly");
        debug_struct.field("score", &self.score);
        debug_struct.field("stats_uri", &self.stats_uri);
        debug_struct.field("anomaly_uri", &self.anomaly_uri);
        debug_struct.field("distribution_deviation", &self.distribution_deviation);
        debug_struct.field(
            "anomaly_detection_threshold",
            &self.anomaly_detection_threshold,
        );
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::FeatureOnlineStore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureOnlineStore");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("state", &self.state);
        debug_struct.field(
            "dedicated_serving_endpoint",
            &self.dedicated_serving_endpoint,
        );
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        debug_struct.field("storage_type", &self.storage_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_online_store::Bigtable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Bigtable");
        debug_struct.field("auto_scaling", &self.auto_scaling);
        debug_struct.field(
            "enable_direct_bigtable_access",
            &self.enable_direct_bigtable_access,
        );
        debug_struct.field("bigtable_metadata", &self.bigtable_metadata);
        debug_struct.field("zone", &self.zone);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_online_store::bigtable::AutoScaling {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutoScaling");
        debug_struct.field("min_node_count", &self.min_node_count);
        debug_struct.field("max_node_count", &self.max_node_count);
        debug_struct.field("cpu_utilization_target", &self.cpu_utilization_target);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_online_store::bigtable::BigtableMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigtableMetadata");
        debug_struct.field("tenant_project_id", &self.tenant_project_id);
        debug_struct.field("instance_id", &self.instance_id);
        debug_struct.field("table_id", &self.table_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_online_store::Optimized {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Optimized");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_online_store::DedicatedServingEndpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DedicatedServingEndpoint");
        debug_struct.field(
            "public_endpoint_domain_name",
            &self.public_endpoint_domain_name,
        );
        debug_struct.field(
            "private_service_connect_config",
            &self.private_service_connect_config,
        );
        debug_struct.field("service_attachment", &self.service_attachment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::CreateFeatureOnlineStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureOnlineStoreRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("feature_online_store", &self.feature_online_store);
        debug_struct.field("feature_online_store_id", &self.feature_online_store_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::GetFeatureOnlineStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFeatureOnlineStoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::ListFeatureOnlineStoresRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureOnlineStoresRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::ListFeatureOnlineStoresResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureOnlineStoresResponse");
        debug_struct.field("feature_online_stores", &self.feature_online_stores);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::UpdateFeatureOnlineStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureOnlineStoreRequest");
        debug_struct.field("feature_online_store", &self.feature_online_store);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::DeleteFeatureOnlineStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureOnlineStoreRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::CreateFeatureViewRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureViewRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("feature_view", &self.feature_view);
        debug_struct.field("feature_view_id", &self.feature_view_id);
        debug_struct.field("run_sync_immediately", &self.run_sync_immediately);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::GetFeatureViewRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFeatureViewRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::ListFeatureViewsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureViewsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::ListFeatureViewsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureViewsResponse");
        debug_struct.field("feature_views", &self.feature_views);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::UpdateFeatureViewRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureViewRequest");
        debug_struct.field("feature_view", &self.feature_view);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::DeleteFeatureViewRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureViewRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::CreateFeatureOnlineStoreOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureOnlineStoreOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::UpdateFeatureOnlineStoreOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureOnlineStoreOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::CreateFeatureViewOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureViewOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::UpdateFeatureViewOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureViewOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::SyncFeatureViewRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SyncFeatureViewRequest");
        debug_struct.field("feature_view", &self.feature_view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::SyncFeatureViewResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SyncFeatureViewResponse");
        debug_struct.field("feature_view_sync", &self.feature_view_sync);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::GetFeatureViewSyncRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFeatureViewSyncRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::ListFeatureViewSyncsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureViewSyncsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::ListFeatureViewSyncsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureViewSyncsResponse");
        debug_struct.field("feature_view_syncs", &self.feature_view_syncs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::FeatureViewDataKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureViewDataKey");
        debug_struct.field("key_oneof", &self.key_oneof);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::feature_view_data_key::CompositeKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompositeKey");
        debug_struct.field("parts", &self.parts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::FetchFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchFeatureValuesRequest");
        debug_struct.field("feature_view", &self.feature_view);
        debug_struct.field("data_key", &self.data_key);
        debug_struct.field("data_format", &self.data_format);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::FetchFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchFeatureValuesResponse");
        debug_struct.field("data_key", &self.data_key);
        debug_struct.field("format", &self.format);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::fetch_feature_values_response::FeatureNameValuePairList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureNameValuePairList");
        debug_struct.field("features", &self.features);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug
    for super::fetch_feature_values_response::feature_name_value_pair_list::FeatureNameValuePair
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureNameValuePair");
        debug_struct.field("name", &self.name);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::NearestNeighborQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NearestNeighborQuery");
        debug_struct.field("neighbor_count", &self.neighbor_count);
        debug_struct.field("string_filters", &self.string_filters);
        debug_struct.field("numeric_filters", &self.numeric_filters);
        debug_struct.field(
            "per_crowding_attribute_neighbor_count",
            &self.per_crowding_attribute_neighbor_count,
        );
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("instance", &self.instance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::nearest_neighbor_query::Embedding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Embedding");
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::nearest_neighbor_query::StringFilter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StringFilter");
        debug_struct.field("name", &self.name);
        debug_struct.field("allow_tokens", &self.allow_tokens);
        debug_struct.field("deny_tokens", &self.deny_tokens);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::nearest_neighbor_query::NumericFilter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NumericFilter");
        debug_struct.field("name", &self.name);
        debug_struct.field("op", &self.op);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::nearest_neighbor_query::Parameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Parameters");
        debug_struct.field(
            "approximate_neighbor_candidates",
            &self.approximate_neighbor_candidates,
        );
        debug_struct.field(
            "leaf_nodes_search_fraction",
            &self.leaf_nodes_search_fraction,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::SearchNearestEntitiesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchNearestEntitiesRequest");
        debug_struct.field("feature_view", &self.feature_view);
        debug_struct.field("query", &self.query);
        debug_struct.field("return_full_entity", &self.return_full_entity);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::NearestNeighbors {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NearestNeighbors");
        debug_struct.field("neighbors", &self.neighbors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::nearest_neighbors::Neighbor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Neighbor");
        debug_struct.field("entity_id", &self.entity_id);
        debug_struct.field("distance", &self.distance);
        debug_struct.field("entity_key_values", &self.entity_key_values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::SearchNearestEntitiesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchNearestEntitiesResponse");
        debug_struct.field("nearest_neighbors", &self.nearest_neighbors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::FeatureViewDirectWriteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureViewDirectWriteRequest");
        debug_struct.field("feature_view", &self.feature_view);
        debug_struct.field(
            "data_key_and_feature_values",
            &self.data_key_and_feature_values,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::feature_view_direct_write_request::DataKeyAndFeatureValues {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataKeyAndFeatureValues");
        debug_struct.field("data_key", &self.data_key);
        debug_struct.field("features", &self.features);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug
    for super::feature_view_direct_write_request::data_key_and_feature_values::Feature
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Feature");
        debug_struct.field("name", &self.name);
        debug_struct.field("data_oneof", &self.data_oneof);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::FeatureViewDirectWriteResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureViewDirectWriteResponse");
        debug_struct.field("status", &self.status);
        debug_struct.field("write_responses", &self.write_responses);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::feature_view_direct_write_response::WriteResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteResponse");
        debug_struct.field("data_key", &self.data_key);
        debug_struct.field("online_store_write_time", &self.online_store_write_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::GenerateFetchAccessTokenRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateFetchAccessTokenRequest");
        debug_struct.field("feature_view", &self.feature_view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-service")]
impl std::fmt::Debug for super::GenerateFetchAccessTokenResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateFetchAccessTokenResponse");
        debug_struct.field("access_token", &self.access_token);
        debug_struct.field("expire_time", &self.expire_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::CreateFeatureGroupRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureGroupRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("feature_group", &self.feature_group);
        debug_struct.field("feature_group_id", &self.feature_group_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::GetFeatureGroupRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFeatureGroupRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::ListFeatureGroupsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureGroupsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::ListFeatureGroupsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeatureGroupsResponse");
        debug_struct.field("feature_groups", &self.feature_groups);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::UpdateFeatureGroupRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureGroupRequest");
        debug_struct.field("feature_group", &self.feature_group);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::DeleteFeatureGroupRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureGroupRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::CreateFeatureGroupOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureGroupOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::UpdateFeatureGroupOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureGroupOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "data-foundry-service",
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "evaluation-service",
    feature = "feature-online-store-admin-service",
    feature = "feature-online-store-service",
    feature = "feature-registry-service",
    feature = "featurestore-online-serving-service",
    feature = "featurestore-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "index-endpoint-service",
    feature = "index-service",
    feature = "job-service",
    feature = "llm-utility-service",
    feature = "match-service",
    feature = "metadata-service",
    feature = "migration-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "prediction-service",
    feature = "reasoning-engine-execution-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
    feature = "specialist-pool-service",
    feature = "tensorboard-service",
    feature = "vertex-rag-data-service",
    feature = "vertex-rag-service",
    feature = "vizier-service",
))]
impl std::fmt::Debug for super::CreateRegistryFeatureOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateRegistryFeatureOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-registry-service")]
impl std::fmt::Debug for super::UpdateFeatureOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "featurestore-online-serving-service",
    feature = "featurestore-service",
))]
impl std::fmt::Debug for super::IdMatcher {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IdMatcher");
        debug_struct.field("ids", &self.ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "featurestore-online-serving-service",
    feature = "featurestore-service",
))]
impl std::fmt::Debug for super::FeatureSelector {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureSelector");
        debug_struct.field("id_matcher", &self.id_matcher);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::FeatureView {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureView");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("sync_config", &self.sync_config);
        debug_struct.field("index_config", &self.index_config);
        debug_struct.field("optimized_config", &self.optimized_config);
        debug_struct.field("service_agent_type", &self.service_agent_type);
        debug_struct.field("service_account_email", &self.service_account_email);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        debug_struct.field("bigtable_metadata", &self.bigtable_metadata);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::BigQuerySource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigQuerySource");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("entity_id_columns", &self.entity_id_columns);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::SyncConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SyncConfig");
        debug_struct.field("cron", &self.cron);
        debug_struct.field("continuous", &self.continuous);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::IndexConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexConfig");
        debug_struct.field("embedding_column", &self.embedding_column);
        debug_struct.field("filter_columns", &self.filter_columns);
        debug_struct.field("crowding_column", &self.crowding_column);
        debug_struct.field("embedding_dimension", &self.embedding_dimension);
        debug_struct.field("distance_measure_type", &self.distance_measure_type);
        debug_struct.field("algorithm_config", &self.algorithm_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::index_config::BruteForceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BruteForceConfig");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::index_config::TreeAHConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TreeAHConfig");
        debug_struct.field("leaf_node_embedding_count", &self.leaf_node_embedding_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::FeatureRegistrySource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureRegistrySource");
        debug_struct.field("feature_groups", &self.feature_groups);
        debug_struct.field("project_number", &self.project_number);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::feature_registry_source::FeatureGroup {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureGroup");
        debug_struct.field("feature_group_id", &self.feature_group_id);
        debug_struct.field("feature_ids", &self.feature_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::VertexRagSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexRagSource");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("rag_corpus_id", &self.rag_corpus_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::OptimizedConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OptimizedConfig");
        debug_struct.field("automatic_resources", &self.automatic_resources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view::BigtableMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigtableMetadata");
        debug_struct.field("read_app_profile", &self.read_app_profile);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::FeatureViewSync {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureViewSync");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("run_time", &self.run_time);
        debug_struct.field("final_status", &self.final_status);
        debug_struct.field("sync_summary", &self.sync_summary);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "feature-online-store-admin-service")]
impl std::fmt::Debug for super::feature_view_sync::SyncSummary {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SyncSummary");
        debug_struct.field("row_synced", &self.row_synced);
        debug_struct.field("total_slot", &self.total_slot);
        debug_struct.field("system_watermark_time", &self.system_watermark_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::Featurestore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Featurestore");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("online_serving_config", &self.online_serving_config);
        debug_struct.field("state", &self.state);
        debug_struct.field("online_storage_ttl_days", &self.online_storage_ttl_days);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::featurestore::OnlineServingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OnlineServingConfig");
        debug_struct.field("fixed_node_count", &self.fixed_node_count);
        debug_struct.field("scaling", &self.scaling);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::featurestore::online_serving_config::Scaling {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Scaling");
        debug_struct.field("min_node_count", &self.min_node_count);
        debug_struct.field("max_node_count", &self.max_node_count);
        debug_struct.field("cpu_utilization_target", &self.cpu_utilization_target);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::FeaturestoreMonitoringConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeaturestoreMonitoringConfig");
        debug_struct.field("snapshot_analysis", &self.snapshot_analysis);
        debug_struct.field("import_features_analysis", &self.import_features_analysis);
        debug_struct.field(
            "numerical_threshold_config",
            &self.numerical_threshold_config,
        );
        debug_struct.field(
            "categorical_threshold_config",
            &self.categorical_threshold_config,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::featurestore_monitoring_config::SnapshotAnalysis {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SnapshotAnalysis");
        debug_struct.field("disabled", &self.disabled);
        debug_struct.field("monitoring_interval_days", &self.monitoring_interval_days);
        debug_struct.field("staleness_days", &self.staleness_days);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::featurestore_monitoring_config::ImportFeaturesAnalysis {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportFeaturesAnalysis");
        debug_struct.field("state", &self.state);
        debug_struct.field(
            "anomaly_detection_baseline",
            &self.anomaly_detection_baseline,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::featurestore_monitoring_config::ThresholdConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ThresholdConfig");
        debug_struct.field("threshold", &self.threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::WriteFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteFeatureValuesRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("payloads", &self.payloads);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::WriteFeatureValuesPayload {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteFeatureValuesPayload");
        debug_struct.field("entity_id", &self.entity_id);
        debug_struct.field("feature_values", &self.feature_values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::WriteFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteFeatureValuesResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::ReadFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadFeatureValuesRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("entity_id", &self.entity_id);
        debug_struct.field("feature_selector", &self.feature_selector);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::ReadFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadFeatureValuesResponse");
        debug_struct.field("header", &self.header);
        debug_struct.field("entity_view", &self.entity_view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::read_feature_values_response::FeatureDescriptor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureDescriptor");
        debug_struct.field("id", &self.id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::read_feature_values_response::Header {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Header");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("feature_descriptors", &self.feature_descriptors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::read_feature_values_response::EntityView {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityView");
        debug_struct.field("entity_id", &self.entity_id);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::read_feature_values_response::entity_view::Data {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Data");
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::StreamingReadFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingReadFeatureValuesRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("entity_ids", &self.entity_ids);
        debug_struct.field("feature_selector", &self.feature_selector);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::FeatureValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureValue");
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::feature_value::Metadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Metadata");
        debug_struct.field("generate_time", &self.generate_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::StructValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StructValue");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::StructFieldValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StructFieldValue");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-online-serving-service")]
impl std::fmt::Debug for super::FeatureValueList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureValueList");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::CreateFeaturestoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeaturestoreRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("featurestore", &self.featurestore);
        debug_struct.field("featurestore_id", &self.featurestore_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::GetFeaturestoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFeaturestoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ListFeaturestoresRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeaturestoresRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ListFeaturestoresResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeaturestoresResponse");
        debug_struct.field("featurestores", &self.featurestores);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::UpdateFeaturestoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeaturestoreRequest");
        debug_struct.field("featurestore", &self.featurestore);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::DeleteFeaturestoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeaturestoreRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ImportFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportFeatureValuesRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("entity_id_field", &self.entity_id_field);
        debug_struct.field("feature_specs", &self.feature_specs);
        debug_struct.field("disable_online_serving", &self.disable_online_serving);
        debug_struct.field("worker_count", &self.worker_count);
        debug_struct.field(
            "disable_ingestion_analysis",
            &self.disable_ingestion_analysis,
        );
        debug_struct.field("source", &self.source);
        debug_struct.field("feature_time_source", &self.feature_time_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::import_feature_values_request::FeatureSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureSpec");
        debug_struct.field("id", &self.id);
        debug_struct.field("source_field", &self.source_field);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ImportFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportFeatureValuesResponse");
        debug_struct.field("imported_entity_count", &self.imported_entity_count);
        debug_struct.field(
            "imported_feature_value_count",
            &self.imported_feature_value_count,
        );
        debug_struct.field("invalid_row_count", &self.invalid_row_count);
        debug_struct.field(
            "timestamp_outside_retention_rows_count",
            &self.timestamp_outside_retention_rows_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::BatchReadFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchReadFeatureValuesRequest");
        debug_struct.field("featurestore", &self.featurestore);
        debug_struct.field("destination", &self.destination);
        debug_struct.field("pass_through_fields", &self.pass_through_fields);
        debug_struct.field("entity_type_specs", &self.entity_type_specs);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("read_option", &self.read_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::batch_read_feature_values_request::PassThroughField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PassThroughField");
        debug_struct.field("field_name", &self.field_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::batch_read_feature_values_request::EntityTypeSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityTypeSpec");
        debug_struct.field("entity_type_id", &self.entity_type_id);
        debug_struct.field("feature_selector", &self.feature_selector);
        debug_struct.field("settings", &self.settings);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ExportFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportFeatureValuesRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("destination", &self.destination);
        debug_struct.field("feature_selector", &self.feature_selector);
        debug_struct.field("settings", &self.settings);
        debug_struct.field("mode", &self.mode);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::export_feature_values_request::SnapshotExport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SnapshotExport");
        debug_struct.field("snapshot_time", &self.snapshot_time);
        debug_struct.field("start_time", &self.start_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::export_feature_values_request::FullExport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FullExport");
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::DestinationFeatureSetting {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DestinationFeatureSetting");
        debug_struct.field("feature_id", &self.feature_id);
        debug_struct.field("destination_field", &self.destination_field);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::FeatureValueDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureValueDestination");
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ExportFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportFeatureValuesResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::BatchReadFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchReadFeatureValuesResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::CreateEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEntityTypeRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("entity_type_id", &self.entity_type_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::GetEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEntityTypeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ListEntityTypesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEntityTypesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ListEntityTypesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEntityTypesResponse");
        debug_struct.field("entity_types", &self.entity_types);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::UpdateEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEntityTypeRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::DeleteEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteEntityTypeRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::CreateFeatureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("feature", &self.feature);
        debug_struct.field("feature_id", &self.feature_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::BatchCreateFeaturesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateFeaturesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("requests", &self.requests);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::BatchCreateFeaturesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateFeaturesResponse");
        debug_struct.field("features", &self.features);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::GetFeatureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFeatureRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::ListFeaturesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeaturesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("latest_stats_count", &self.latest_stats_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::ListFeaturesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListFeaturesResponse");
        debug_struct.field("features", &self.features);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::SearchFeaturesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchFeaturesRequest");
        debug_struct.field("location", &self.location);
        debug_struct.field("query", &self.query);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::SearchFeaturesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchFeaturesResponse");
        debug_struct.field("features", &self.features);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::UpdateFeatureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeatureRequest");
        debug_struct.field("feature", &self.feature);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::DeleteFeatureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::CreateFeaturestoreOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeaturestoreOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::UpdateFeaturestoreOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFeaturestoreOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ImportFeatureValuesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportFeatureValuesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("imported_entity_count", &self.imported_entity_count);
        debug_struct.field(
            "imported_feature_value_count",
            &self.imported_feature_value_count,
        );
        debug_struct.field("source_uris", &self.source_uris);
        debug_struct.field("invalid_row_count", &self.invalid_row_count);
        debug_struct.field(
            "timestamp_outside_retention_rows_count",
            &self.timestamp_outside_retention_rows_count,
        );
        debug_struct.field("blocking_operation_ids", &self.blocking_operation_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::ExportFeatureValuesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportFeatureValuesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::BatchReadFeatureValuesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchReadFeatureValuesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::DeleteFeatureValuesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureValuesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::CreateEntityTypeOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEntityTypeOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::CreateFeatureOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateFeatureOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "feature-registry-service", feature = "featurestore-service",))]
impl std::fmt::Debug for super::BatchCreateFeaturesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateFeaturesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::DeleteFeatureValuesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureValuesRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("delete_option", &self.delete_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::delete_feature_values_request::SelectEntity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SelectEntity");
        debug_struct.field("entity_id_selector", &self.entity_id_selector);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::delete_feature_values_request::SelectTimeRangeAndFeature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SelectTimeRangeAndFeature");
        debug_struct.field("time_range", &self.time_range);
        debug_struct.field("feature_selector", &self.feature_selector);
        debug_struct.field(
            "skip_online_storage_delete",
            &self.skip_online_storage_delete,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::DeleteFeatureValuesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteFeatureValuesResponse");
        debug_struct.field("response", &self.response);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::delete_feature_values_response::SelectEntity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SelectEntity");
        debug_struct.field(
            "offline_storage_deleted_entity_row_count",
            &self.offline_storage_deleted_entity_row_count,
        );
        debug_struct.field(
            "online_storage_deleted_entity_count",
            &self.online_storage_deleted_entity_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::delete_feature_values_response::SelectTimeRangeAndFeature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SelectTimeRangeAndFeature");
        debug_struct.field("impacted_feature_count", &self.impacted_feature_count);
        debug_struct.field(
            "offline_storage_modified_entity_row_count",
            &self.offline_storage_modified_entity_row_count,
        );
        debug_struct.field(
            "online_storage_modified_entity_count",
            &self.online_storage_modified_entity_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::EntityIdSelector {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityIdSelector");
        debug_struct.field("entity_id_field", &self.entity_id_field);
        debug_struct.field("entity_ids_source", &self.entity_ids_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::CreateCachedContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateCachedContentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("cached_content", &self.cached_content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::GetCachedContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetCachedContentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::UpdateCachedContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateCachedContentRequest");
        debug_struct.field("cached_content", &self.cached_content);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::DeleteCachedContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteCachedContentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::ListCachedContentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCachedContentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-cache-service")]
impl std::fmt::Debug for super::ListCachedContentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCachedContentsResponse");
        debug_struct.field("cached_contents", &self.cached_contents);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::CreateTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTuningJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("tuning_job", &self.tuning_job);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::GetTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTuningJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::ListTuningJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTuningJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::ListTuningJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTuningJobsResponse");
        debug_struct.field("tuning_jobs", &self.tuning_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::CancelTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelTuningJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::RebaseTunedModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RebaseTunedModelRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("tuned_model_ref", &self.tuned_model_ref);
        debug_struct.field("tuning_job", &self.tuning_job);
        debug_struct.field("artifact_destination", &self.artifact_destination);
        debug_struct.field("deploy_to_same_endpoint", &self.deploy_to_same_endpoint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::RebaseTunedModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RebaseTunedModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::HyperparameterTuningJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HyperparameterTuningJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("study_spec", &self.study_spec);
        debug_struct.field("max_trial_count", &self.max_trial_count);
        debug_struct.field("parallel_trial_count", &self.parallel_trial_count);
        debug_struct.field("max_failed_trial_count", &self.max_failed_trial_count);
        debug_struct.field("trial_job_spec", &self.trial_job_spec);
        debug_struct.field("trials", &self.trials);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("error", &self.error);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::Index {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Index");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("metadata_schema_uri", &self.metadata_schema_uri);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("deployed_indexes", &self.deployed_indexes);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("index_stats", &self.index_stats);
        debug_struct.field("index_update_method", &self.index_update_method);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "index-service", feature = "match-service",))]
impl std::fmt::Debug for super::IndexDatapoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexDatapoint");
        debug_struct.field("datapoint_id", &self.datapoint_id);
        debug_struct.field("feature_vector", &self.feature_vector);
        debug_struct.field("sparse_embedding", &self.sparse_embedding);
        debug_struct.field("restricts", &self.restricts);
        debug_struct.field("numeric_restricts", &self.numeric_restricts);
        debug_struct.field("crowding_tag", &self.crowding_tag);
        debug_struct.field("embedding_metadata", &self.embedding_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "index-service", feature = "match-service",))]
impl std::fmt::Debug for super::index_datapoint::SparseEmbedding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SparseEmbedding");
        debug_struct.field("values", &self.values);
        debug_struct.field("dimensions", &self.dimensions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "index-service", feature = "match-service",))]
impl std::fmt::Debug for super::index_datapoint::Restriction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Restriction");
        debug_struct.field("namespace", &self.namespace);
        debug_struct.field("allow_list", &self.allow_list);
        debug_struct.field("deny_list", &self.deny_list);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "index-service", feature = "match-service",))]
impl std::fmt::Debug for super::index_datapoint::NumericRestriction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NumericRestriction");
        debug_struct.field("namespace", &self.namespace);
        debug_struct.field("op", &self.op);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "index-service", feature = "match-service",))]
impl std::fmt::Debug for super::index_datapoint::CrowdingTag {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CrowdingTag");
        debug_struct.field("crowding_attribute", &self.crowding_attribute);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::IndexStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexStats");
        debug_struct.field("vectors_count", &self.vectors_count);
        debug_struct.field("sparse_vectors_count", &self.sparse_vectors_count);
        debug_struct.field("shards_count", &self.shards_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::IndexEndpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexEndpoint");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("deployed_indexes", &self.deployed_indexes);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("network", &self.network);
        debug_struct.field(
            "enable_private_service_connect",
            &self.enable_private_service_connect,
        );
        debug_struct.field(
            "private_service_connect_config",
            &self.private_service_connect_config,
        );
        debug_struct.field("public_endpoint_enabled", &self.public_endpoint_enabled);
        debug_struct.field(
            "public_endpoint_domain_name",
            &self.public_endpoint_domain_name,
        );
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::DeployedIndex {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployedIndex");
        debug_struct.field("id", &self.id);
        debug_struct.field("index", &self.index);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("private_endpoints", &self.private_endpoints);
        debug_struct.field("index_sync_time", &self.index_sync_time);
        debug_struct.field("automatic_resources", &self.automatic_resources);
        debug_struct.field("dedicated_resources", &self.dedicated_resources);
        debug_struct.field("enable_access_logging", &self.enable_access_logging);
        debug_struct.field(
            "enable_datapoint_upsert_logging",
            &self.enable_datapoint_upsert_logging,
        );
        debug_struct.field(
            "deployed_index_auth_config",
            &self.deployed_index_auth_config,
        );
        debug_struct.field("reserved_ip_ranges", &self.reserved_ip_ranges);
        debug_struct.field("deployment_group", &self.deployment_group);
        debug_struct.field("deployment_tier", &self.deployment_tier);
        debug_struct.field("psc_automation_configs", &self.psc_automation_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::DeployedIndexAuthConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployedIndexAuthConfig");
        debug_struct.field("auth_provider", &self.auth_provider);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::deployed_index_auth_config::AuthProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AuthProvider");
        debug_struct.field("audiences", &self.audiences);
        debug_struct.field("allowed_issuers", &self.allowed_issuers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::IndexPrivateEndpoints {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexPrivateEndpoints");
        debug_struct.field("match_grpc_address", &self.match_grpc_address);
        debug_struct.field("service_attachment", &self.service_attachment);
        debug_struct.field("psc_automated_endpoints", &self.psc_automated_endpoints);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::CreateIndexEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateIndexEndpointRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("index_endpoint", &self.index_endpoint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::CreateIndexEndpointOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateIndexEndpointOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::GetIndexEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetIndexEndpointRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::ListIndexEndpointsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIndexEndpointsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::ListIndexEndpointsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIndexEndpointsResponse");
        debug_struct.field("index_endpoints", &self.index_endpoints);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::UpdateIndexEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateIndexEndpointRequest");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::DeleteIndexEndpointRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteIndexEndpointRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::DeployIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployIndexRequest");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("deployed_index", &self.deployed_index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::DeployIndexResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployIndexResponse");
        debug_struct.field("deployed_index", &self.deployed_index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::DeployIndexOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployIndexOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("deployed_index_id", &self.deployed_index_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::UndeployIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployIndexRequest");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("deployed_index_id", &self.deployed_index_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::UndeployIndexResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployIndexResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::UndeployIndexOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployIndexOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::MutateDeployedIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutateDeployedIndexRequest");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("deployed_index", &self.deployed_index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::MutateDeployedIndexResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutateDeployedIndexResponse");
        debug_struct.field("deployed_index", &self.deployed_index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::MutateDeployedIndexOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutateDeployedIndexOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("deployed_index_id", &self.deployed_index_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::CreateIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateIndexRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("index", &self.index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::CreateIndexOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateIndexOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field(
            "nearest_neighbor_search_operation_metadata",
            &self.nearest_neighbor_search_operation_metadata,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::GetIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetIndexRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::ListIndexesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIndexesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::ListIndexesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIndexesResponse");
        debug_struct.field("indexes", &self.indexes);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::UpdateIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateIndexRequest");
        debug_struct.field("index", &self.index);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::UpdateIndexOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateIndexOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field(
            "nearest_neighbor_search_operation_metadata",
            &self.nearest_neighbor_search_operation_metadata,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::DeleteIndexRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteIndexRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::UpsertDatapointsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpsertDatapointsRequest");
        debug_struct.field("index", &self.index);
        debug_struct.field("datapoints", &self.datapoints);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::UpsertDatapointsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpsertDatapointsResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::RemoveDatapointsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RemoveDatapointsRequest");
        debug_struct.field("index", &self.index);
        debug_struct.field("datapoint_ids", &self.datapoint_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::RemoveDatapointsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RemoveDatapointsResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::NearestNeighborSearchOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NearestNeighborSearchOperationMetadata");
        debug_struct.field("content_validation_stats", &self.content_validation_stats);
        debug_struct.field("data_bytes_count", &self.data_bytes_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::nearest_neighbor_search_operation_metadata::RecordError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecordError");
        debug_struct.field("error_type", &self.error_type);
        debug_struct.field("error_message", &self.error_message);
        debug_struct.field("source_gcs_uri", &self.source_gcs_uri);
        debug_struct.field("embedding_id", &self.embedding_id);
        debug_struct.field("raw_record", &self.raw_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-service")]
impl std::fmt::Debug for super::nearest_neighbor_search_operation_metadata::ContentValidationStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContentValidationStats");
        debug_struct.field("source_gcs_uri", &self.source_gcs_uri);
        debug_struct.field("valid_record_count", &self.valid_record_count);
        debug_struct.field("invalid_record_count", &self.invalid_record_count);
        debug_struct.field("partial_errors", &self.partial_errors);
        debug_struct.field("valid_sparse_record_count", &self.valid_sparse_record_count);
        debug_struct.field(
            "invalid_sparse_record_count",
            &self.invalid_sparse_record_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::AvroSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AvroSource");
        debug_struct.field("gcs_source", &self.gcs_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::CsvSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CsvSource");
        debug_struct.field("gcs_source", &self.gcs_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "featurestore-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "prediction-service",
    feature = "vertex-rag-data-service",
))]
impl std::fmt::Debug for super::GcsSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsSource");
        debug_struct.field("uris", &self.uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "featurestore-service",
    feature = "gen-ai-tuning-service",
    feature = "job-service",
    feature = "model-service",
    feature = "pipeline-service",
    feature = "vertex-rag-data-service",
))]
impl std::fmt::Debug for super::GcsDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsDestination");
        debug_struct.field("output_uri_prefix", &self.output_uri_prefix);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-registry-service",
    feature = "featurestore-service",
    feature = "job-service",
))]
impl std::fmt::Debug for super::BigQuerySource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigQuerySource");
        debug_struct.field("input_uri", &self.input_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "endpoint-service",
    feature = "featurestore-service",
    feature = "job-service",
    feature = "pipeline-service",
    feature = "vertex-rag-data-service",
))]
impl std::fmt::Debug for super::BigQueryDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigQueryDestination");
        debug_struct.field("output_uri", &self.output_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::CsvDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CsvDestination");
        debug_struct.field("gcs_destination", &self.gcs_destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "featurestore-service")]
impl std::fmt::Debug for super::TFRecordDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TFRecordDestination");
        debug_struct.field("gcs_destination", &self.gcs_destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ContainerRegistryDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContainerRegistryDestination");
        debug_struct.field("output_uri", &self.output_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::GoogleDriveSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GoogleDriveSource");
        debug_struct.field("resource_ids", &self.resource_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::google_drive_source::ResourceId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceId");
        debug_struct.field("resource_type", &self.resource_type);
        debug_struct.field("resource_id", &self.resource_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::DirectUploadSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectUploadSource");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::SlackSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SlackSource");
        debug_struct.field("channels", &self.channels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::slack_source::SlackChannels {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SlackChannels");
        debug_struct.field("channels", &self.channels);
        debug_struct.field("api_key_config", &self.api_key_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::slack_source::slack_channels::SlackChannel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SlackChannel");
        debug_struct.field("channel_id", &self.channel_id);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::JiraSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("JiraSource");
        debug_struct.field("jira_queries", &self.jira_queries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::jira_source::JiraQueries {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("JiraQueries");
        debug_struct.field("projects", &self.projects);
        debug_struct.field("custom_queries", &self.custom_queries);
        debug_struct.field("email", &self.email);
        debug_struct.field("server_uri", &self.server_uri);
        debug_struct.field("api_key_config", &self.api_key_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::SharePointSources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SharePointSources");
        debug_struct.field("share_point_sources", &self.share_point_sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::share_point_sources::SharePointSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SharePointSource");
        debug_struct.field("client_id", &self.client_id);
        debug_struct.field("client_secret", &self.client_secret);
        debug_struct.field("tenant_id", &self.tenant_id);
        debug_struct.field("sharepoint_site_name", &self.sharepoint_site_name);
        debug_struct.field("file_id", &self.file_id);
        debug_struct.field("folder_source", &self.folder_source);
        debug_struct.field("drive_source", &self.drive_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CreateCustomJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateCustomJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("custom_job", &self.custom_job);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetCustomJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetCustomJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListCustomJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCustomJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListCustomJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCustomJobsResponse");
        debug_struct.field("custom_jobs", &self.custom_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DeleteCustomJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteCustomJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CancelCustomJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelCustomJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CreateDataLabelingJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDataLabelingJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("data_labeling_job", &self.data_labeling_job);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetDataLabelingJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDataLabelingJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListDataLabelingJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDataLabelingJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListDataLabelingJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDataLabelingJobsResponse");
        debug_struct.field("data_labeling_jobs", &self.data_labeling_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DeleteDataLabelingJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDataLabelingJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CancelDataLabelingJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelDataLabelingJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CreateHyperparameterTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateHyperparameterTuningJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("hyperparameter_tuning_job", &self.hyperparameter_tuning_job);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetHyperparameterTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetHyperparameterTuningJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListHyperparameterTuningJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListHyperparameterTuningJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListHyperparameterTuningJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListHyperparameterTuningJobsResponse");
        debug_struct.field(
            "hyperparameter_tuning_jobs",
            &self.hyperparameter_tuning_jobs,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DeleteHyperparameterTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteHyperparameterTuningJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CancelHyperparameterTuningJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelHyperparameterTuningJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CreateNasJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateNasJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("nas_job", &self.nas_job);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetNasJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetNasJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListNasJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNasJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListNasJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNasJobsResponse");
        debug_struct.field("nas_jobs", &self.nas_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DeleteNasJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteNasJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CancelNasJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelNasJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetNasTrialDetailRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetNasTrialDetailRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListNasTrialDetailsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNasTrialDetailsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListNasTrialDetailsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNasTrialDetailsResponse");
        debug_struct.field("nas_trial_details", &self.nas_trial_details);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CreateBatchPredictionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateBatchPredictionJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("batch_prediction_job", &self.batch_prediction_job);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetBatchPredictionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetBatchPredictionJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListBatchPredictionJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListBatchPredictionJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListBatchPredictionJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListBatchPredictionJobsResponse");
        debug_struct.field("batch_prediction_jobs", &self.batch_prediction_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DeleteBatchPredictionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteBatchPredictionJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CancelBatchPredictionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelBatchPredictionJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::CreateModelDeploymentMonitoringJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateModelDeploymentMonitoringJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field(
            "model_deployment_monitoring_job",
            &self.model_deployment_monitoring_job,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::SearchModelDeploymentMonitoringStatsAnomaliesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct =
            f.debug_struct("SearchModelDeploymentMonitoringStatsAnomaliesRequest");
        debug_struct.field(
            "model_deployment_monitoring_job",
            &self.model_deployment_monitoring_job,
        );
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        debug_struct.field("feature_display_name", &self.feature_display_name);
        debug_struct.field("objectives", &self.objectives);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug
    for super::search_model_deployment_monitoring_stats_anomalies_request::StatsAnomaliesObjective
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StatsAnomaliesObjective");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("top_feature_count", &self.top_feature_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::SearchModelDeploymentMonitoringStatsAnomaliesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct =
            f.debug_struct("SearchModelDeploymentMonitoringStatsAnomaliesResponse");
        debug_struct.field("monitoring_stats", &self.monitoring_stats);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::GetModelDeploymentMonitoringJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetModelDeploymentMonitoringJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListModelDeploymentMonitoringJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelDeploymentMonitoringJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ListModelDeploymentMonitoringJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelDeploymentMonitoringJobsResponse");
        debug_struct.field(
            "model_deployment_monitoring_jobs",
            &self.model_deployment_monitoring_jobs,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::UpdateModelDeploymentMonitoringJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateModelDeploymentMonitoringJobRequest");
        debug_struct.field(
            "model_deployment_monitoring_job",
            &self.model_deployment_monitoring_job,
        );
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::DeleteModelDeploymentMonitoringJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteModelDeploymentMonitoringJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::PauseModelDeploymentMonitoringJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PauseModelDeploymentMonitoringJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ResumeModelDeploymentMonitoringJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResumeModelDeploymentMonitoringJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::UpdateModelDeploymentMonitoringJobOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct =
            f.debug_struct("UpdateModelDeploymentMonitoringJobOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::LineageSubgraph {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LineageSubgraph");
        debug_struct.field("artifacts", &self.artifacts);
        debug_struct.field("executions", &self.executions);
        debug_struct.field("events", &self.events);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "llm-utility-service")]
impl std::fmt::Debug for super::ComputeTokensRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ComputeTokensRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("instances", &self.instances);
        debug_struct.field("model", &self.model);
        debug_struct.field("contents", &self.contents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "llm-utility-service")]
impl std::fmt::Debug for super::TokensInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TokensInfo");
        debug_struct.field("tokens", &self.tokens);
        debug_struct.field("token_ids", &self.token_ids);
        debug_struct.field("role", &self.role);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "llm-utility-service")]
impl std::fmt::Debug for super::ComputeTokensResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ComputeTokensResponse");
        debug_struct.field("tokens_info", &self.tokens_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "index-endpoint-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::MachineSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MachineSpec");
        debug_struct.field("machine_type", &self.machine_type);
        debug_struct.field("accelerator_type", &self.accelerator_type);
        debug_struct.field("accelerator_count", &self.accelerator_count);
        debug_struct.field("gpu_partition_size", &self.gpu_partition_size);
        debug_struct.field("tpu_topology", &self.tpu_topology);
        debug_struct.field("reservation_affinity", &self.reservation_affinity);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "index-endpoint-service",
    feature = "model-garden-service",
))]
impl std::fmt::Debug for super::DedicatedResources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DedicatedResources");
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("min_replica_count", &self.min_replica_count);
        debug_struct.field("max_replica_count", &self.max_replica_count);
        debug_struct.field("required_replica_count", &self.required_replica_count);
        debug_struct.field("autoscaling_metric_specs", &self.autoscaling_metric_specs);
        debug_struct.field("spot", &self.spot);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "feature-online-store-admin-service",
    feature = "index-endpoint-service",
    feature = "model-garden-service",
))]
impl std::fmt::Debug for super::AutomaticResources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutomaticResources");
        debug_struct.field("min_replica_count", &self.min_replica_count);
        debug_struct.field("max_replica_count", &self.max_replica_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::BatchDedicatedResources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchDedicatedResources");
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("starting_replica_count", &self.starting_replica_count);
        debug_struct.field("max_replica_count", &self.max_replica_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ResourcesConsumed {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourcesConsumed");
        debug_struct.field("replica_hours", &self.replica_hours);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "persistent-resource-service",))]
impl std::fmt::Debug for super::DiskSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DiskSpec");
        debug_struct.field("boot_disk_type", &self.boot_disk_type);
        debug_struct.field("boot_disk_size_gb", &self.boot_disk_size_gb);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::PersistentDiskSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PersistentDiskSpec");
        debug_struct.field("disk_type", &self.disk_type);
        debug_struct.field("disk_size_gb", &self.disk_size_gb);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::NfsMount {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NfsMount");
        debug_struct.field("server", &self.server);
        debug_struct.field("path", &self.path);
        debug_struct.field("mount_point", &self.mount_point);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "index-endpoint-service",
    feature = "model-garden-service",
))]
impl std::fmt::Debug for super::AutoscalingMetricSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutoscalingMetricSpec");
        debug_struct.field("metric_name", &self.metric_name);
        debug_struct.field("target", &self.target);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ShieldedVmConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ShieldedVmConfig");
        debug_struct.field("enable_secure_boot", &self.enable_secure_boot);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ManualBatchTuningParameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ManualBatchTuningParameters");
        debug_struct.field("batch_size", &self.batch_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::FindNeighborsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FindNeighborsRequest");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("deployed_index_id", &self.deployed_index_id);
        debug_struct.field("queries", &self.queries);
        debug_struct.field("return_full_datapoint", &self.return_full_datapoint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::find_neighbors_request::Query {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Query");
        debug_struct.field("datapoint", &self.datapoint);
        debug_struct.field("neighbor_count", &self.neighbor_count);
        debug_struct.field(
            "per_crowding_attribute_neighbor_count",
            &self.per_crowding_attribute_neighbor_count,
        );
        debug_struct.field(
            "approximate_neighbor_count",
            &self.approximate_neighbor_count,
        );
        debug_struct.field(
            "fraction_leaf_nodes_to_search_override",
            &self.fraction_leaf_nodes_to_search_override,
        );
        debug_struct.field("ranking", &self.ranking);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::find_neighbors_request::query::Rrf {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Rrf");
        debug_struct.field("alpha", &self.alpha);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::FindNeighborsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FindNeighborsResponse");
        debug_struct.field("nearest_neighbors", &self.nearest_neighbors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::find_neighbors_response::Neighbor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Neighbor");
        debug_struct.field("datapoint", &self.datapoint);
        debug_struct.field("distance", &self.distance);
        debug_struct.field("sparse_distance", &self.sparse_distance);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::find_neighbors_response::NearestNeighbors {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NearestNeighbors");
        debug_struct.field("id", &self.id);
        debug_struct.field("neighbors", &self.neighbors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::ReadIndexDatapointsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadIndexDatapointsRequest");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("deployed_index_id", &self.deployed_index_id);
        debug_struct.field("ids", &self.ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "match-service")]
impl std::fmt::Debug for super::ReadIndexDatapointsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadIndexDatapointsResponse");
        debug_struct.field("datapoints", &self.datapoints);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::MetadataSchema {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetadataSchema");
        debug_struct.field("name", &self.name);
        debug_struct.field("schema_version", &self.schema_version);
        debug_struct.field("schema", &self.schema);
        debug_struct.field("schema_type", &self.schema_type);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("description", &self.description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::CreateMetadataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateMetadataStoreRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("metadata_store", &self.metadata_store);
        debug_struct.field("metadata_store_id", &self.metadata_store_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::CreateMetadataStoreOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateMetadataStoreOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::GetMetadataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetMetadataStoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListMetadataStoresRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMetadataStoresRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListMetadataStoresResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMetadataStoresResponse");
        debug_struct.field("metadata_stores", &self.metadata_stores);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::DeleteMetadataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteMetadataStoreRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::DeleteMetadataStoreOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteMetadataStoreOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::CreateArtifactRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateArtifactRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("artifact", &self.artifact);
        debug_struct.field("artifact_id", &self.artifact_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::GetArtifactRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetArtifactRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListArtifactsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListArtifactsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListArtifactsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListArtifactsResponse");
        debug_struct.field("artifacts", &self.artifacts);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::UpdateArtifactRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateArtifactRequest");
        debug_struct.field("artifact", &self.artifact);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("allow_missing", &self.allow_missing);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::DeleteArtifactRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteArtifactRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("etag", &self.etag);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeArtifactsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeArtifactsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeArtifactsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeArtifactsResponse");
        debug_struct.field("purge_count", &self.purge_count);
        debug_struct.field("purge_sample", &self.purge_sample);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeArtifactsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeArtifactsMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::CreateContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateContextRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("context", &self.context);
        debug_struct.field("context_id", &self.context_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::GetContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetContextRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListContextsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListContextsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListContextsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListContextsResponse");
        debug_struct.field("contexts", &self.contexts);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::UpdateContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateContextRequest");
        debug_struct.field("context", &self.context);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("allow_missing", &self.allow_missing);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::DeleteContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteContextRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        debug_struct.field("etag", &self.etag);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeContextsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeContextsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeContextsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeContextsResponse");
        debug_struct.field("purge_count", &self.purge_count);
        debug_struct.field("purge_sample", &self.purge_sample);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeContextsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeContextsMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::AddContextArtifactsAndExecutionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddContextArtifactsAndExecutionsRequest");
        debug_struct.field("context", &self.context);
        debug_struct.field("artifacts", &self.artifacts);
        debug_struct.field("executions", &self.executions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::AddContextArtifactsAndExecutionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddContextArtifactsAndExecutionsResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::AddContextChildrenRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddContextChildrenRequest");
        debug_struct.field("context", &self.context);
        debug_struct.field("child_contexts", &self.child_contexts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::AddContextChildrenResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddContextChildrenResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::RemoveContextChildrenRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RemoveContextChildrenRequest");
        debug_struct.field("context", &self.context);
        debug_struct.field("child_contexts", &self.child_contexts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::RemoveContextChildrenResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RemoveContextChildrenResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::QueryContextLineageSubgraphRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryContextLineageSubgraphRequest");
        debug_struct.field("context", &self.context);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::CreateExecutionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateExecutionRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("execution", &self.execution);
        debug_struct.field("execution_id", &self.execution_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::GetExecutionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetExecutionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListExecutionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListExecutionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListExecutionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListExecutionsResponse");
        debug_struct.field("executions", &self.executions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::UpdateExecutionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateExecutionRequest");
        debug_struct.field("execution", &self.execution);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("allow_missing", &self.allow_missing);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::DeleteExecutionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteExecutionRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("etag", &self.etag);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeExecutionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeExecutionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeExecutionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeExecutionsResponse");
        debug_struct.field("purge_count", &self.purge_count);
        debug_struct.field("purge_sample", &self.purge_sample);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::PurgeExecutionsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeExecutionsMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::AddExecutionEventsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddExecutionEventsRequest");
        debug_struct.field("execution", &self.execution);
        debug_struct.field("events", &self.events);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::AddExecutionEventsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddExecutionEventsResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::QueryExecutionInputsAndOutputsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryExecutionInputsAndOutputsRequest");
        debug_struct.field("execution", &self.execution);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::CreateMetadataSchemaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateMetadataSchemaRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("metadata_schema", &self.metadata_schema);
        debug_struct.field("metadata_schema_id", &self.metadata_schema_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::GetMetadataSchemaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetMetadataSchemaRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListMetadataSchemasRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMetadataSchemasRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::ListMetadataSchemasResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMetadataSchemasResponse");
        debug_struct.field("metadata_schemas", &self.metadata_schemas);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::QueryArtifactLineageSubgraphRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryArtifactLineageSubgraphRequest");
        debug_struct.field("artifact", &self.artifact);
        debug_struct.field("max_hops", &self.max_hops);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::MetadataStore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetadataStore");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("description", &self.description);
        debug_struct.field("state", &self.state);
        debug_struct.field("dataplex_config", &self.dataplex_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::metadata_store::MetadataStoreState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetadataStoreState");
        debug_struct.field("disk_utilization_bytes", &self.disk_utilization_bytes);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "metadata-service")]
impl std::fmt::Debug for super::metadata_store::DataplexConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataplexConfig");
        debug_struct.field("enabled_pipelines_lineage", &self.enabled_pipelines_lineage);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::MigratableResource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigratableResource");
        debug_struct.field("last_migrate_time", &self.last_migrate_time);
        debug_struct.field("last_update_time", &self.last_update_time);
        debug_struct.field("resource", &self.resource);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migratable_resource::MlEngineModelVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MlEngineModelVersion");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migratable_resource::AutomlModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutomlModel");
        debug_struct.field("model", &self.model);
        debug_struct.field("model_display_name", &self.model_display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migratable_resource::AutomlDataset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutomlDataset");
        debug_struct.field("dataset", &self.dataset);
        debug_struct.field("dataset_display_name", &self.dataset_display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migratable_resource::DataLabelingDataset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataLabelingDataset");
        debug_struct.field("dataset", &self.dataset);
        debug_struct.field("dataset_display_name", &self.dataset_display_name);
        debug_struct.field(
            "data_labeling_annotated_datasets",
            &self.data_labeling_annotated_datasets,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug
    for super::migratable_resource::data_labeling_dataset::DataLabelingAnnotatedDataset
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataLabelingAnnotatedDataset");
        debug_struct.field("annotated_dataset", &self.annotated_dataset);
        debug_struct.field(
            "annotated_dataset_display_name",
            &self.annotated_dataset_display_name,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::SearchMigratableResourcesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchMigratableResourcesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::SearchMigratableResourcesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchMigratableResourcesResponse");
        debug_struct.field("migratable_resources", &self.migratable_resources);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::BatchMigrateResourcesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchMigrateResourcesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("migrate_resource_requests", &self.migrate_resource_requests);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::MigrateResourceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateResourceRequest");
        debug_struct.field("request", &self.request);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migrate_resource_request::MigrateMlEngineModelVersionConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateMlEngineModelVersionConfig");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("model_version", &self.model_version);
        debug_struct.field("model_display_name", &self.model_display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migrate_resource_request::MigrateAutomlModelConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateAutomlModelConfig");
        debug_struct.field("model", &self.model);
        debug_struct.field("model_display_name", &self.model_display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migrate_resource_request::MigrateAutomlDatasetConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateAutomlDatasetConfig");
        debug_struct.field("dataset", &self.dataset);
        debug_struct.field("dataset_display_name", &self.dataset_display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migrate_resource_request::MigrateDataLabelingDatasetConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateDataLabelingDatasetConfig");
        debug_struct.field("dataset", &self.dataset);
        debug_struct.field("dataset_display_name", &self.dataset_display_name);
        debug_struct.field(
            "migrate_data_labeling_annotated_dataset_configs",
            &self.migrate_data_labeling_annotated_dataset_configs,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::migrate_resource_request::migrate_data_labeling_dataset_config::MigrateDataLabelingAnnotatedDatasetConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateDataLabelingAnnotatedDatasetConfig");
        debug_struct.field("annotated_dataset", &self.annotated_dataset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::BatchMigrateResourcesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchMigrateResourcesResponse");
        debug_struct.field(
            "migrate_resource_responses",
            &self.migrate_resource_responses,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::MigrateResourceResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MigrateResourceResponse");
        debug_struct.field("migratable_resource", &self.migratable_resource);
        debug_struct.field("migrated_resource", &self.migrated_resource);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::BatchMigrateResourcesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchMigrateResourcesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("partial_results", &self.partial_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "migration-service")]
impl std::fmt::Debug for super::batch_migrate_resources_operation_metadata::PartialResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartialResult");
        debug_struct.field("request", &self.request);
        debug_struct.field("result", &self.result);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::Model {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Model");
        debug_struct.field("name", &self.name);
        debug_struct.field("version_id", &self.version_id);
        debug_struct.field("version_aliases", &self.version_aliases);
        debug_struct.field("version_create_time", &self.version_create_time);
        debug_struct.field("version_update_time", &self.version_update_time);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("version_description", &self.version_description);
        debug_struct.field("default_checkpoint_id", &self.default_checkpoint_id);
        debug_struct.field("predict_schemata", &self.predict_schemata);
        debug_struct.field("metadata_schema_uri", &self.metadata_schema_uri);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("supported_export_formats", &self.supported_export_formats);
        debug_struct.field("training_pipeline", &self.training_pipeline);
        debug_struct.field("pipeline_job", &self.pipeline_job);
        debug_struct.field("container_spec", &self.container_spec);
        debug_struct.field("artifact_uri", &self.artifact_uri);
        debug_struct.field(
            "supported_deployment_resources_types",
            &self.supported_deployment_resources_types,
        );
        debug_struct.field(
            "supported_input_storage_formats",
            &self.supported_input_storage_formats,
        );
        debug_struct.field(
            "supported_output_storage_formats",
            &self.supported_output_storage_formats,
        );
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("deployed_models", &self.deployed_models);
        debug_struct.field("explanation_spec", &self.explanation_spec);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("data_stats", &self.data_stats);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("model_source_info", &self.model_source_info);
        debug_struct.field("original_model_info", &self.original_model_info);
        debug_struct.field("metadata_artifact", &self.metadata_artifact);
        debug_struct.field("base_model_source", &self.base_model_source);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        debug_struct.field("checkpoints", &self.checkpoints);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::model::ExportFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportFormat");
        debug_struct.field("id", &self.id);
        debug_struct.field("exportable_contents", &self.exportable_contents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::model::DataStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataStats");
        debug_struct.field("training_data_items_count", &self.training_data_items_count);
        debug_struct.field(
            "validation_data_items_count",
            &self.validation_data_items_count,
        );
        debug_struct.field("test_data_items_count", &self.test_data_items_count);
        debug_struct.field(
            "training_annotations_count",
            &self.training_annotations_count,
        );
        debug_struct.field(
            "validation_annotations_count",
            &self.validation_annotations_count,
        );
        debug_struct.field("test_annotations_count", &self.test_annotations_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::model::OriginalModelInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OriginalModelInfo");
        debug_struct.field("model", &self.model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::model::BaseModelSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BaseModelSource");
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::LargeModelReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LargeModelReference");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::ModelGardenSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelGardenSource");
        debug_struct.field("public_model_name", &self.public_model_name);
        debug_struct.field("version_id", &self.version_id);
        debug_struct.field("skip_hf_model_cache", &self.skip_hf_model_cache);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::GenieSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenieSource");
        debug_struct.field("base_model_uri", &self.base_model_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::PredictSchemata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PredictSchemata");
        debug_struct.field("instance_schema_uri", &self.instance_schema_uri);
        debug_struct.field("parameters_schema_uri", &self.parameters_schema_uri);
        debug_struct.field("prediction_schema_uri", &self.prediction_schema_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::ModelContainerSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelContainerSpec");
        debug_struct.field("image_uri", &self.image_uri);
        debug_struct.field("command", &self.command);
        debug_struct.field("args", &self.args);
        debug_struct.field("env", &self.env);
        debug_struct.field("ports", &self.ports);
        debug_struct.field("predict_route", &self.predict_route);
        debug_struct.field("health_route", &self.health_route);
        debug_struct.field("invoke_route_prefix", &self.invoke_route_prefix);
        debug_struct.field("grpc_ports", &self.grpc_ports);
        debug_struct.field("deployment_timeout", &self.deployment_timeout);
        debug_struct.field("shared_memory_size_mb", &self.shared_memory_size_mb);
        debug_struct.field("startup_probe", &self.startup_probe);
        debug_struct.field("health_probe", &self.health_probe);
        debug_struct.field("liveness_probe", &self.liveness_probe);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::Port {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Port");
        debug_struct.field("container_port", &self.container_port);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::ModelSourceInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelSourceInfo");
        debug_struct.field("source_type", &self.source_type);
        debug_struct.field("copy", &self.copy);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::Probe {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Probe");
        debug_struct.field("period_seconds", &self.period_seconds);
        debug_struct.field("timeout_seconds", &self.timeout_seconds);
        debug_struct.field("failure_threshold", &self.failure_threshold);
        debug_struct.field("success_threshold", &self.success_threshold);
        debug_struct.field("initial_delay_seconds", &self.initial_delay_seconds);
        debug_struct.field("probe_type", &self.probe_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::probe::ExecAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExecAction");
        debug_struct.field("command", &self.command);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::probe::HttpGetAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HttpGetAction");
        debug_struct.field("path", &self.path);
        debug_struct.field("port", &self.port);
        debug_struct.field("host", &self.host);
        debug_struct.field("scheme", &self.scheme);
        debug_struct.field("http_headers", &self.http_headers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::probe::GrpcAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GrpcAction");
        debug_struct.field("port", &self.port);
        debug_struct.field("service", &self.service);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::probe::TcpSocketAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TcpSocketAction");
        debug_struct.field("port", &self.port);
        debug_struct.field("host", &self.host);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::probe::HttpHeader {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HttpHeader");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "model-service",
    feature = "pipeline-service",
))]
impl std::fmt::Debug for super::Checkpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Checkpoint");
        debug_struct.field("checkpoint_id", &self.checkpoint_id);
        debug_struct.field("epoch", &self.epoch);
        debug_struct.field("step", &self.step);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelDeploymentMonitoringJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelDeploymentMonitoringJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("state", &self.state);
        debug_struct.field("schedule_state", &self.schedule_state);
        debug_struct.field(
            "latest_monitoring_pipeline_metadata",
            &self.latest_monitoring_pipeline_metadata,
        );
        debug_struct.field(
            "model_deployment_monitoring_objective_configs",
            &self.model_deployment_monitoring_objective_configs,
        );
        debug_struct.field(
            "model_deployment_monitoring_schedule_config",
            &self.model_deployment_monitoring_schedule_config,
        );
        debug_struct.field("logging_sampling_strategy", &self.logging_sampling_strategy);
        debug_struct.field(
            "model_monitoring_alert_config",
            &self.model_monitoring_alert_config,
        );
        debug_struct.field(
            "predict_instance_schema_uri",
            &self.predict_instance_schema_uri,
        );
        debug_struct.field("sample_predict_instance", &self.sample_predict_instance);
        debug_struct.field(
            "analysis_instance_schema_uri",
            &self.analysis_instance_schema_uri,
        );
        debug_struct.field("bigquery_tables", &self.bigquery_tables);
        debug_struct.field("log_ttl", &self.log_ttl);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("next_schedule_time", &self.next_schedule_time);
        debug_struct.field(
            "stats_anomalies_base_directory",
            &self.stats_anomalies_base_directory,
        );
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field(
            "enable_monitoring_pipeline_logs",
            &self.enable_monitoring_pipeline_logs,
        );
        debug_struct.field("error", &self.error);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::model_deployment_monitoring_job::LatestMonitoringPipelineMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LatestMonitoringPipelineMetadata");
        debug_struct.field("run_time", &self.run_time);
        debug_struct.field("status", &self.status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelDeploymentMonitoringBigQueryTable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelDeploymentMonitoringBigQueryTable");
        debug_struct.field("log_source", &self.log_source);
        debug_struct.field("log_type", &self.log_type);
        debug_struct.field("bigquery_table_path", &self.bigquery_table_path);
        debug_struct.field(
            "request_response_logging_schema_version",
            &self.request_response_logging_schema_version,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelDeploymentMonitoringObjectiveConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelDeploymentMonitoringObjectiveConfig");
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        debug_struct.field("objective_config", &self.objective_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelDeploymentMonitoringScheduleConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelDeploymentMonitoringScheduleConfig");
        debug_struct.field("monitor_interval", &self.monitor_interval);
        debug_struct.field("monitor_window", &self.monitor_window);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelMonitoringStatsAnomalies {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelMonitoringStatsAnomalies");
        debug_struct.field("objective", &self.objective);
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        debug_struct.field("anomaly_count", &self.anomaly_count);
        debug_struct.field("feature_stats", &self.feature_stats);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::model_monitoring_stats_anomalies::FeatureHistoricStatsAnomalies {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureHistoricStatsAnomalies");
        debug_struct.field("feature_display_name", &self.feature_display_name);
        debug_struct.field("threshold", &self.threshold);
        debug_struct.field("training_stats", &self.training_stats);
        debug_struct.field("prediction_stats", &self.prediction_stats);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ModelEvaluation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelEvaluation");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("metrics_schema_uri", &self.metrics_schema_uri);
        debug_struct.field("metrics", &self.metrics);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("slice_dimensions", &self.slice_dimensions);
        debug_struct.field("data_item_schema_uri", &self.data_item_schema_uri);
        debug_struct.field("annotation_schema_uri", &self.annotation_schema_uri);
        debug_struct.field("model_explanation", &self.model_explanation);
        debug_struct.field("explanation_specs", &self.explanation_specs);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::model_evaluation::ModelEvaluationExplanationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelEvaluationExplanationSpec");
        debug_struct.field("explanation_type", &self.explanation_type);
        debug_struct.field("explanation_spec", &self.explanation_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ModelEvaluationSlice {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelEvaluationSlice");
        debug_struct.field("name", &self.name);
        debug_struct.field("slice", &self.slice);
        debug_struct.field("metrics_schema_uri", &self.metrics_schema_uri);
        debug_struct.field("metrics", &self.metrics);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("model_explanation", &self.model_explanation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::model_evaluation_slice::Slice {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Slice");
        debug_struct.field("dimension", &self.dimension);
        debug_struct.field("value", &self.value);
        debug_struct.field("slice_spec", &self.slice_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::model_evaluation_slice::slice::SliceSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SliceSpec");
        debug_struct.field("configs", &self.configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::model_evaluation_slice::slice::slice_spec::SliceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SliceConfig");
        debug_struct.field("kind", &self.kind);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::model_evaluation_slice::slice::slice_spec::Range {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Range");
        debug_struct.field("low", &self.low);
        debug_struct.field("high", &self.high);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::model_evaluation_slice::slice::slice_spec::Value {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Value");
        debug_struct.field("kind", &self.kind);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::GetPublisherModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetPublisherModelRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("view", &self.view);
        debug_struct.field("is_hugging_face_model", &self.is_hugging_face_model);
        debug_struct.field("hugging_face_token", &self.hugging_face_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::DeployRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployRequest");
        debug_struct.field("destination", &self.destination);
        debug_struct.field("model_config", &self.model_config);
        debug_struct.field("endpoint_config", &self.endpoint_config);
        debug_struct.field("deploy_config", &self.deploy_config);
        debug_struct.field("artifacts", &self.artifacts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::deploy_request::ModelConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelConfig");
        debug_struct.field("accept_eula", &self.accept_eula);
        debug_struct.field("hugging_face_access_token", &self.hugging_face_access_token);
        debug_struct.field(
            "hugging_face_cache_enabled",
            &self.hugging_face_cache_enabled,
        );
        debug_struct.field("model_display_name", &self.model_display_name);
        debug_struct.field("container_spec", &self.container_spec);
        debug_struct.field("model_user_id", &self.model_user_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::deploy_request::EndpointConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EndpointConfig");
        debug_struct.field("endpoint_display_name", &self.endpoint_display_name);
        debug_struct.field(
            "dedicated_endpoint_enabled",
            &self.dedicated_endpoint_enabled,
        );
        debug_struct.field(
            "dedicated_endpoint_disabled",
            &self.dedicated_endpoint_disabled,
        );
        debug_struct.field("endpoint_user_id", &self.endpoint_user_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::deploy_request::DeployConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployConfig");
        debug_struct.field("dedicated_resources", &self.dedicated_resources);
        debug_struct.field("fast_tryout_enabled", &self.fast_tryout_enabled);
        debug_struct.field("system_labels", &self.system_labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::DeployResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployResponse");
        debug_struct.field("publisher_model", &self.publisher_model);
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("model", &self.model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::DeployOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("publisher_model", &self.publisher_model);
        debug_struct.field("destination", &self.destination);
        debug_struct.field("project_number", &self.project_number);
        debug_struct.field("model_id", &self.model_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelMonitoringObjectiveConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelMonitoringObjectiveConfig");
        debug_struct.field("training_dataset", &self.training_dataset);
        debug_struct.field(
            "training_prediction_skew_detection_config",
            &self.training_prediction_skew_detection_config,
        );
        debug_struct.field(
            "prediction_drift_detection_config",
            &self.prediction_drift_detection_config,
        );
        debug_struct.field("explanation_config", &self.explanation_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::model_monitoring_objective_config::TrainingDataset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainingDataset");
        debug_struct.field("data_format", &self.data_format);
        debug_struct.field("target_field", &self.target_field);
        debug_struct.field("logging_sampling_strategy", &self.logging_sampling_strategy);
        debug_struct.field("data_source", &self.data_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug
    for super::model_monitoring_objective_config::TrainingPredictionSkewDetectionConfig
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainingPredictionSkewDetectionConfig");
        debug_struct.field("skew_thresholds", &self.skew_thresholds);
        debug_struct.field(
            "attribution_score_skew_thresholds",
            &self.attribution_score_skew_thresholds,
        );
        debug_struct.field("default_skew_threshold", &self.default_skew_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::model_monitoring_objective_config::PredictionDriftDetectionConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PredictionDriftDetectionConfig");
        debug_struct.field("drift_thresholds", &self.drift_thresholds);
        debug_struct.field(
            "attribution_score_drift_thresholds",
            &self.attribution_score_drift_thresholds,
        );
        debug_struct.field("default_drift_threshold", &self.default_drift_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::model_monitoring_objective_config::ExplanationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationConfig");
        debug_struct.field("enable_feature_attributes", &self.enable_feature_attributes);
        debug_struct.field("explanation_baseline", &self.explanation_baseline);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug
    for super::model_monitoring_objective_config::explanation_config::ExplanationBaseline
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplanationBaseline");
        debug_struct.field("prediction_format", &self.prediction_format);
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ModelMonitoringAlertConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelMonitoringAlertConfig");
        debug_struct.field("enable_logging", &self.enable_logging);
        debug_struct.field("notification_channels", &self.notification_channels);
        debug_struct.field("alert", &self.alert);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::model_monitoring_alert_config::EmailAlertConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EmailAlertConfig");
        debug_struct.field("user_emails", &self.user_emails);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::ThresholdConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ThresholdConfig");
        debug_struct.field("threshold", &self.threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::SamplingStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SamplingStrategy");
        debug_struct.field("random_sample_config", &self.random_sample_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::sampling_strategy::RandomSampleConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RandomSampleConfig");
        debug_struct.field("sample_rate", &self.sample_rate);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UploadModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UploadModelRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("parent_model", &self.parent_model);
        debug_struct.field("model_id", &self.model_id);
        debug_struct.field("model", &self.model);
        debug_struct.field("service_account", &self.service_account);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UploadModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UploadModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UploadModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UploadModelResponse");
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version_id", &self.model_version_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::GetModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetModelRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelsResponse");
        debug_struct.field("models", &self.models);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelVersionsRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelVersionsResponse");
        debug_struct.field("models", &self.models);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelVersionCheckpointsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelVersionCheckpointsRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ModelVersionCheckpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelVersionCheckpoint");
        debug_struct.field("checkpoint_id", &self.checkpoint_id);
        debug_struct.field("epoch", &self.epoch);
        debug_struct.field("step", &self.step);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelVersionCheckpointsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelVersionCheckpointsResponse");
        debug_struct.field("checkpoints", &self.checkpoints);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UpdateModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateModelRequest");
        debug_struct.field("model", &self.model);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UpdateExplanationDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateExplanationDatasetRequest");
        debug_struct.field("model", &self.model);
        debug_struct.field("examples", &self.examples);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UpdateExplanationDatasetOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateExplanationDatasetOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::DeleteModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteModelRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::DeleteModelVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteModelVersionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::MergeVersionAliasesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MergeVersionAliasesRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("version_aliases", &self.version_aliases);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ExportModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportModelRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("output_config", &self.output_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::export_model_request::OutputConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputConfig");
        debug_struct.field("export_format_id", &self.export_format_id);
        debug_struct.field("artifact_destination", &self.artifact_destination);
        debug_struct.field("image_destination", &self.image_destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ExportModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("output_info", &self.output_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::export_model_operation_metadata::OutputInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputInfo");
        debug_struct.field("artifact_output_uri", &self.artifact_output_uri);
        debug_struct.field("image_output_uri", &self.image_output_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::UpdateExplanationDatasetResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateExplanationDatasetResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ExportModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportModelResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::CopyModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CopyModelRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("source_model", &self.source_model);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("destination_model", &self.destination_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::CopyModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CopyModelOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::CopyModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CopyModelResponse");
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version_id", &self.model_version_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ImportModelEvaluationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportModelEvaluationRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("model_evaluation", &self.model_evaluation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::BatchImportModelEvaluationSlicesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchImportModelEvaluationSlicesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("model_evaluation_slices", &self.model_evaluation_slices);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::BatchImportModelEvaluationSlicesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchImportModelEvaluationSlicesResponse");
        debug_struct.field(
            "imported_model_evaluation_slices",
            &self.imported_model_evaluation_slices,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::BatchImportEvaluatedAnnotationsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchImportEvaluatedAnnotationsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("evaluated_annotations", &self.evaluated_annotations);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::BatchImportEvaluatedAnnotationsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchImportEvaluatedAnnotationsResponse");
        debug_struct.field(
            "imported_evaluated_annotations_count",
            &self.imported_evaluated_annotations_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::GetModelEvaluationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetModelEvaluationRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelEvaluationsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelEvaluationsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelEvaluationsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelEvaluationsResponse");
        debug_struct.field("model_evaluations", &self.model_evaluations);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::GetModelEvaluationSliceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetModelEvaluationSliceRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelEvaluationSlicesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelEvaluationSlicesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-service")]
impl std::fmt::Debug for super::ListModelEvaluationSlicesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListModelEvaluationSlicesResponse");
        debug_struct.field("model_evaluation_slices", &self.model_evaluation_slices);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::NasJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NasJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("nas_job_spec", &self.nas_job_spec);
        debug_struct.field("nas_job_output", &self.nas_job_output);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("error", &self.error);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field(
            "enable_restricted_image_training",
            &self.enable_restricted_image_training,
        );
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::NasTrialDetail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NasTrialDetail");
        debug_struct.field("name", &self.name);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("search_trial", &self.search_trial);
        debug_struct.field("train_trial", &self.train_trial);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::NasJobSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NasJobSpec");
        debug_struct.field("resume_nas_job_id", &self.resume_nas_job_id);
        debug_struct.field("search_space_spec", &self.search_space_spec);
        debug_struct.field("nas_algorithm_spec", &self.nas_algorithm_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::nas_job_spec::MultiTrialAlgorithmSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MultiTrialAlgorithmSpec");
        debug_struct.field("multi_trial_algorithm", &self.multi_trial_algorithm);
        debug_struct.field("metric", &self.metric);
        debug_struct.field("search_trial_spec", &self.search_trial_spec);
        debug_struct.field("train_trial_spec", &self.train_trial_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::nas_job_spec::multi_trial_algorithm_spec::MetricSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetricSpec");
        debug_struct.field("metric_id", &self.metric_id);
        debug_struct.field("goal", &self.goal);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::nas_job_spec::multi_trial_algorithm_spec::SearchTrialSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchTrialSpec");
        debug_struct.field("search_trial_job_spec", &self.search_trial_job_spec);
        debug_struct.field("max_trial_count", &self.max_trial_count);
        debug_struct.field("max_parallel_trial_count", &self.max_parallel_trial_count);
        debug_struct.field("max_failed_trial_count", &self.max_failed_trial_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::nas_job_spec::multi_trial_algorithm_spec::TrainTrialSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainTrialSpec");
        debug_struct.field("train_trial_job_spec", &self.train_trial_job_spec);
        debug_struct.field("max_parallel_trial_count", &self.max_parallel_trial_count);
        debug_struct.field("frequency", &self.frequency);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::NasJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NasJobOutput");
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::nas_job_output::MultiTrialJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MultiTrialJobOutput");
        debug_struct.field("search_trials", &self.search_trials);
        debug_struct.field("train_trials", &self.train_trials);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::NasTrial {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NasTrial");
        debug_struct.field("id", &self.id);
        debug_struct.field("state", &self.state);
        debug_struct.field("final_measurement", &self.final_measurement);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::NetworkSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NetworkSpec");
        debug_struct.field("enable_internet_access", &self.enable_internet_access);
        debug_struct.field("network", &self.network);
        debug_struct.field("subnetwork", &self.subnetwork);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::NotebookEucConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookEucConfig");
        debug_struct.field("euc_disabled", &self.euc_disabled);
        debug_struct.field("bypass_actas_check", &self.bypass_actas_check);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::NotebookExecutionJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookExecutionJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("execution_timeout", &self.execution_timeout);
        debug_struct.field("schedule_resource_name", &self.schedule_resource_name);
        debug_struct.field("job_state", &self.job_state);
        debug_struct.field("status", &self.status);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("kernel_name", &self.kernel_name);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("notebook_source", &self.notebook_source);
        debug_struct.field("environment_spec", &self.environment_spec);
        debug_struct.field("execution_sink", &self.execution_sink);
        debug_struct.field("execution_identity", &self.execution_identity);
        debug_struct.field("runtime_environment", &self.runtime_environment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::notebook_execution_job::DataformRepositorySource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataformRepositorySource");
        debug_struct.field(
            "dataform_repository_resource_name",
            &self.dataform_repository_resource_name,
        );
        debug_struct.field("commit_sha", &self.commit_sha);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::notebook_execution_job::GcsNotebookSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsNotebookSource");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("generation", &self.generation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::notebook_execution_job::DirectNotebookSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectNotebookSource");
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::notebook_execution_job::CustomEnvironmentSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomEnvironmentSpec");
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("persistent_disk_spec", &self.persistent_disk_spec);
        debug_struct.field("network_spec", &self.network_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::notebook_execution_job::WorkbenchRuntime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WorkbenchRuntime");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::NotebookIdleShutdownConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookIdleShutdownConfig");
        debug_struct.field("idle_timeout", &self.idle_timeout);
        debug_struct.field("idle_shutdown_disabled", &self.idle_shutdown_disabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::NotebookRuntimeTemplate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookRuntimeTemplate");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("is_default", &self.is_default);
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("data_persistent_disk_spec", &self.data_persistent_disk_spec);
        debug_struct.field("network_spec", &self.network_spec);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("idle_shutdown_config", &self.idle_shutdown_config);
        debug_struct.field("euc_config", &self.euc_config);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("notebook_runtime_type", &self.notebook_runtime_type);
        debug_struct.field("shielded_vm_config", &self.shielded_vm_config);
        debug_struct.field("network_tags", &self.network_tags);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("software_config", &self.software_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::NotebookRuntime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookRuntime");
        debug_struct.field("name", &self.name);
        debug_struct.field("runtime_user", &self.runtime_user);
        debug_struct.field(
            "notebook_runtime_template_ref",
            &self.notebook_runtime_template_ref,
        );
        debug_struct.field("proxy_uri", &self.proxy_uri);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("health_state", &self.health_state);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("runtime_state", &self.runtime_state);
        debug_struct.field("is_upgradable", &self.is_upgradable);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("expiration_time", &self.expiration_time);
        debug_struct.field("version", &self.version);
        debug_struct.field("notebook_runtime_type", &self.notebook_runtime_type);
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("data_persistent_disk_spec", &self.data_persistent_disk_spec);
        debug_struct.field("network_spec", &self.network_spec);
        debug_struct.field("idle_shutdown_config", &self.idle_shutdown_config);
        debug_struct.field("euc_config", &self.euc_config);
        debug_struct.field("shielded_vm_config", &self.shielded_vm_config);
        debug_struct.field("network_tags", &self.network_tags);
        debug_struct.field("software_config", &self.software_config);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::NotebookRuntimeTemplateRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookRuntimeTemplateRef");
        debug_struct.field("notebook_runtime_template", &self.notebook_runtime_template);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::CreateNotebookRuntimeTemplateRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateNotebookRuntimeTemplateRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("notebook_runtime_template", &self.notebook_runtime_template);
        debug_struct.field(
            "notebook_runtime_template_id",
            &self.notebook_runtime_template_id,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::CreateNotebookRuntimeTemplateOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateNotebookRuntimeTemplateOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::GetNotebookRuntimeTemplateRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetNotebookRuntimeTemplateRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ListNotebookRuntimeTemplatesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNotebookRuntimeTemplatesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ListNotebookRuntimeTemplatesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNotebookRuntimeTemplatesResponse");
        debug_struct.field(
            "notebook_runtime_templates",
            &self.notebook_runtime_templates,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::DeleteNotebookRuntimeTemplateRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteNotebookRuntimeTemplateRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::UpdateNotebookRuntimeTemplateRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateNotebookRuntimeTemplateRequest");
        debug_struct.field("notebook_runtime_template", &self.notebook_runtime_template);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::AssignNotebookRuntimeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssignNotebookRuntimeRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("notebook_runtime_template", &self.notebook_runtime_template);
        debug_struct.field("notebook_runtime", &self.notebook_runtime);
        debug_struct.field("notebook_runtime_id", &self.notebook_runtime_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::AssignNotebookRuntimeOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssignNotebookRuntimeOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::GetNotebookRuntimeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetNotebookRuntimeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ListNotebookRuntimesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNotebookRuntimesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ListNotebookRuntimesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNotebookRuntimesResponse");
        debug_struct.field("notebook_runtimes", &self.notebook_runtimes);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::DeleteNotebookRuntimeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteNotebookRuntimeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::UpgradeNotebookRuntimeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpgradeNotebookRuntimeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::UpgradeNotebookRuntimeOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpgradeNotebookRuntimeOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::UpgradeNotebookRuntimeResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpgradeNotebookRuntimeResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::StartNotebookRuntimeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StartNotebookRuntimeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::StartNotebookRuntimeOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StartNotebookRuntimeOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::StartNotebookRuntimeResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StartNotebookRuntimeResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::StopNotebookRuntimeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StopNotebookRuntimeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::StopNotebookRuntimeOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StopNotebookRuntimeOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::StopNotebookRuntimeResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StopNotebookRuntimeResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "notebook-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::CreateNotebookExecutionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateNotebookExecutionJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("notebook_execution_job", &self.notebook_execution_job);
        debug_struct.field("notebook_execution_job_id", &self.notebook_execution_job_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::CreateNotebookExecutionJobOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateNotebookExecutionJobOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::GetNotebookExecutionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetNotebookExecutionJobRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("view", &self.view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ListNotebookExecutionJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNotebookExecutionJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("view", &self.view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ListNotebookExecutionJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListNotebookExecutionJobsResponse");
        debug_struct.field("notebook_execution_jobs", &self.notebook_execution_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::DeleteNotebookExecutionJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteNotebookExecutionJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::PostStartupScriptConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PostStartupScriptConfig");
        debug_struct.field("post_startup_script", &self.post_startup_script);
        debug_struct.field("post_startup_script_url", &self.post_startup_script_url);
        debug_struct.field(
            "post_startup_script_behavior",
            &self.post_startup_script_behavior,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::ColabImage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ColabImage");
        debug_struct.field("release_name", &self.release_name);
        debug_struct.field("description", &self.description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "notebook-service")]
impl std::fmt::Debug for super::NotebookSoftwareConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotebookSoftwareConfig");
        debug_struct.field("env", &self.env);
        debug_struct.field(
            "post_startup_script_config",
            &self.post_startup_script_config,
        );
        debug_struct.field("runtime_image", &self.runtime_image);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::Schema {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Schema");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("format", &self.format);
        debug_struct.field("title", &self.title);
        debug_struct.field("description", &self.description);
        debug_struct.field("nullable", &self.nullable);
        debug_struct.field("default", &self.default);
        debug_struct.field("items", &self.items);
        debug_struct.field("min_items", &self.min_items);
        debug_struct.field("max_items", &self.max_items);
        debug_struct.field("r#enum", &self.r#enum);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("property_ordering", &self.property_ordering);
        debug_struct.field("required", &self.required);
        debug_struct.field("min_properties", &self.min_properties);
        debug_struct.field("max_properties", &self.max_properties);
        debug_struct.field("minimum", &self.minimum);
        debug_struct.field("maximum", &self.maximum);
        debug_struct.field("min_length", &self.min_length);
        debug_struct.field("max_length", &self.max_length);
        debug_struct.field("pattern", &self.pattern);
        debug_struct.field("example", &self.example);
        debug_struct.field("any_of", &self.any_of);
        debug_struct.field("additional_properties", &self.additional_properties);
        debug_struct.field("r#ref", &self.r#ref);
        debug_struct.field("defs", &self.defs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "feature-online-store-admin-service",
    feature = "feature-registry-service",
    feature = "featurestore-service",
    feature = "gen-ai-tuning-service",
    feature = "index-endpoint-service",
    feature = "index-service",
    feature = "job-service",
    feature = "metadata-service",
    feature = "migration-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
    feature = "specialist-pool-service",
    feature = "tensorboard-service",
    feature = "vertex-rag-data-service",
    feature = "vizier-service",
))]
impl std::fmt::Debug for super::GenericOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenericOperationMetadata");
        debug_struct.field("partial_failures", &self.partial_failures);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "feature-online-store-admin-service",
    feature = "feature-registry-service",
    feature = "featurestore-service",
    feature = "index-endpoint-service",
    feature = "index-service",
    feature = "job-service",
    feature = "metadata-service",
    feature = "model-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
    feature = "specialist-pool-service",
    feature = "tensorboard-service",
    feature = "vertex-rag-data-service",
))]
impl std::fmt::Debug for super::DeleteOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::PersistentResource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PersistentResource");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("resource_pools", &self.resource_pools);
        debug_struct.field("state", &self.state);
        debug_struct.field("error", &self.error);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("network", &self.network);
        debug_struct.field("psc_interface_config", &self.psc_interface_config);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("resource_runtime_spec", &self.resource_runtime_spec);
        debug_struct.field("resource_runtime", &self.resource_runtime);
        debug_struct.field("reserved_ip_ranges", &self.reserved_ip_ranges);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::ResourcePool {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourcePool");
        debug_struct.field("id", &self.id);
        debug_struct.field("machine_spec", &self.machine_spec);
        debug_struct.field("replica_count", &self.replica_count);
        debug_struct.field("disk_spec", &self.disk_spec);
        debug_struct.field("used_replica_count", &self.used_replica_count);
        debug_struct.field("autoscaling_spec", &self.autoscaling_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::resource_pool::AutoscalingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutoscalingSpec");
        debug_struct.field("min_replica_count", &self.min_replica_count);
        debug_struct.field("max_replica_count", &self.max_replica_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::ResourceRuntimeSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceRuntimeSpec");
        debug_struct.field("service_account_spec", &self.service_account_spec);
        debug_struct.field("ray_spec", &self.ray_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::RaySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RaySpec");
        debug_struct.field("image_uri", &self.image_uri);
        debug_struct.field("resource_pool_images", &self.resource_pool_images);
        debug_struct.field(
            "head_node_resource_pool_id",
            &self.head_node_resource_pool_id,
        );
        debug_struct.field("ray_metric_spec", &self.ray_metric_spec);
        debug_struct.field("ray_logs_spec", &self.ray_logs_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::ResourceRuntime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceRuntime");
        debug_struct.field("access_uris", &self.access_uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::ServiceAccountSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ServiceAccountSpec");
        debug_struct.field(
            "enable_custom_service_account",
            &self.enable_custom_service_account,
        );
        debug_struct.field("service_account", &self.service_account);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::RayMetricSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RayMetricSpec");
        debug_struct.field("disabled", &self.disabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::RayLogsSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RayLogsSpec");
        debug_struct.field("disabled", &self.disabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::CreatePersistentResourceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreatePersistentResourceRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("persistent_resource", &self.persistent_resource);
        debug_struct.field("persistent_resource_id", &self.persistent_resource_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::CreatePersistentResourceOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreatePersistentResourceOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::UpdatePersistentResourceOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdatePersistentResourceOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::RebootPersistentResourceOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RebootPersistentResourceOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("progress_message", &self.progress_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::GetPersistentResourceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetPersistentResourceRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::ListPersistentResourcesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListPersistentResourcesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::ListPersistentResourcesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListPersistentResourcesResponse");
        debug_struct.field("persistent_resources", &self.persistent_resources);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::DeletePersistentResourceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeletePersistentResourceRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::UpdatePersistentResourceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdatePersistentResourceRequest");
        debug_struct.field("persistent_resource", &self.persistent_resource);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "persistent-resource-service")]
impl std::fmt::Debug for super::RebootPersistentResourceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RebootPersistentResourceRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::PipelineJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PipelineJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("pipeline_spec", &self.pipeline_spec);
        debug_struct.field("state", &self.state);
        debug_struct.field("job_detail", &self.job_detail);
        debug_struct.field("error", &self.error);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("runtime_config", &self.runtime_config);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("network", &self.network);
        debug_struct.field("reserved_ip_ranges", &self.reserved_ip_ranges);
        debug_struct.field("psc_interface_config", &self.psc_interface_config);
        debug_struct.field("template_uri", &self.template_uri);
        debug_struct.field("template_metadata", &self.template_metadata);
        debug_struct.field("schedule_name", &self.schedule_name);
        debug_struct.field("preflight_validations", &self.preflight_validations);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::pipeline_job::RuntimeConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RuntimeConfig");
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("gcs_output_directory", &self.gcs_output_directory);
        debug_struct.field("parameter_values", &self.parameter_values);
        debug_struct.field("failure_policy", &self.failure_policy);
        debug_struct.field("input_artifacts", &self.input_artifacts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::pipeline_job::runtime_config::InputArtifact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputArtifact");
        debug_struct.field("kind", &self.kind);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::PipelineTemplateMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PipelineTemplateMetadata");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::PipelineJobDetail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PipelineJobDetail");
        debug_struct.field("pipeline_context", &self.pipeline_context);
        debug_struct.field("pipeline_run_context", &self.pipeline_run_context);
        debug_struct.field("task_details", &self.task_details);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::PipelineTaskDetail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PipelineTaskDetail");
        debug_struct.field("task_id", &self.task_id);
        debug_struct.field("parent_task_id", &self.parent_task_id);
        debug_struct.field("task_name", &self.task_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("executor_detail", &self.executor_detail);
        debug_struct.field("state", &self.state);
        debug_struct.field("execution", &self.execution);
        debug_struct.field("error", &self.error);
        debug_struct.field("pipeline_task_status", &self.pipeline_task_status);
        debug_struct.field("inputs", &self.inputs);
        debug_struct.field("outputs", &self.outputs);
        debug_struct.field("task_unique_name", &self.task_unique_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::pipeline_task_detail::PipelineTaskStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PipelineTaskStatus");
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("state", &self.state);
        debug_struct.field("error", &self.error);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::pipeline_task_detail::ArtifactList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ArtifactList");
        debug_struct.field("artifacts", &self.artifacts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::PipelineTaskExecutorDetail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PipelineTaskExecutorDetail");
        debug_struct.field("details", &self.details);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::pipeline_task_executor_detail::ContainerDetail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContainerDetail");
        debug_struct.field("main_job", &self.main_job);
        debug_struct.field("pre_caching_check_job", &self.pre_caching_check_job);
        debug_struct.field("failed_main_jobs", &self.failed_main_jobs);
        debug_struct.field(
            "failed_pre_caching_check_jobs",
            &self.failed_pre_caching_check_jobs,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::pipeline_task_executor_detail::CustomJobDetail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomJobDetail");
        debug_struct.field("job", &self.job);
        debug_struct.field("failed_jobs", &self.failed_jobs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::BatchCancelPipelineJobsOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCancelPipelineJobsOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::CreateTrainingPipelineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTrainingPipelineRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("training_pipeline", &self.training_pipeline);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::GetTrainingPipelineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTrainingPipelineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::ListTrainingPipelinesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTrainingPipelinesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::ListTrainingPipelinesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTrainingPipelinesResponse");
        debug_struct.field("training_pipelines", &self.training_pipelines);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::DeleteTrainingPipelineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTrainingPipelineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::CancelTrainingPipelineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelTrainingPipelineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::CreatePipelineJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreatePipelineJobRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("pipeline_job", &self.pipeline_job);
        debug_struct.field("pipeline_job_id", &self.pipeline_job_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::GetPipelineJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetPipelineJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::ListPipelineJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListPipelineJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::ListPipelineJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListPipelineJobsResponse");
        debug_struct.field("pipeline_jobs", &self.pipeline_jobs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::DeletePipelineJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeletePipelineJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::BatchDeletePipelineJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchDeletePipelineJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("names", &self.names);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::BatchDeletePipelineJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchDeletePipelineJobsResponse");
        debug_struct.field("pipeline_jobs", &self.pipeline_jobs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::CancelPipelineJobRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CancelPipelineJobRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::BatchCancelPipelineJobsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCancelPipelineJobsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("names", &self.names);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::BatchCancelPipelineJobsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCancelPipelineJobsResponse");
        debug_struct.field("pipeline_jobs", &self.pipeline_jobs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::PredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("instances", &self.instances);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("labels", &self.labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::PredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PredictResponse");
        debug_struct.field("predictions", &self.predictions);
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version_id", &self.model_version_id);
        debug_struct.field("model_display_name", &self.model_display_name);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::RawPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RawPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("http_body", &self.http_body);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamRawPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamRawPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("http_body", &self.http_body);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::DirectPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("inputs", &self.inputs);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::DirectPredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectPredictResponse");
        debug_struct.field("outputs", &self.outputs);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::DirectRawPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectRawPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("method_name", &self.method_name);
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::DirectRawPredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectRawPredictResponse");
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamDirectPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamDirectPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("inputs", &self.inputs);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamDirectPredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamDirectPredictResponse");
        debug_struct.field("outputs", &self.outputs);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamDirectRawPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamDirectRawPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("method_name", &self.method_name);
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamDirectRawPredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamDirectRawPredictResponse");
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamingPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("inputs", &self.inputs);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamingPredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingPredictResponse");
        debug_struct.field("outputs", &self.outputs);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamingRawPredictRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingRawPredictRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("method_name", &self.method_name);
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::StreamingRawPredictResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingRawPredictResponse");
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ExplainRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplainRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("instances", &self.instances);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("explanation_spec_override", &self.explanation_spec_override);
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::ExplainResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExplainResponse");
        debug_struct.field("explanations", &self.explanations);
        debug_struct.field("deployed_model_id", &self.deployed_model_id);
        debug_struct.field("predictions", &self.predictions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "llm-utility-service")]
impl std::fmt::Debug for super::CountTokensRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CountTokensRequest");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("model", &self.model);
        debug_struct.field("instances", &self.instances);
        debug_struct.field("contents", &self.contents);
        debug_struct.field("system_instruction", &self.system_instruction);
        debug_struct.field("tools", &self.tools);
        debug_struct.field("generation_config", &self.generation_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "llm-utility-service")]
impl std::fmt::Debug for super::CountTokensResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CountTokensResponse");
        debug_struct.field("total_tokens", &self.total_tokens);
        debug_struct.field("total_billable_characters", &self.total_billable_characters);
        debug_struct.field("prompt_tokens_details", &self.prompt_tokens_details);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::GenerateContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateContentRequest");
        debug_struct.field("model", &self.model);
        debug_struct.field("contents", &self.contents);
        debug_struct.field("system_instruction", &self.system_instruction);
        debug_struct.field("cached_content", &self.cached_content);
        debug_struct.field("tools", &self.tools);
        debug_struct.field("tool_config", &self.tool_config);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("safety_settings", &self.safety_settings);
        debug_struct.field("model_armor_config", &self.model_armor_config);
        debug_struct.field("generation_config", &self.generation_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::GenerateContentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateContentResponse");
        debug_struct.field("candidates", &self.candidates);
        debug_struct.field("model_version", &self.model_version);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("response_id", &self.response_id);
        debug_struct.field("prompt_feedback", &self.prompt_feedback);
        debug_struct.field("usage_metadata", &self.usage_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::generate_content_response::PromptFeedback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PromptFeedback");
        debug_struct.field("block_reason", &self.block_reason);
        debug_struct.field("safety_ratings", &self.safety_ratings);
        debug_struct.field("block_reason_message", &self.block_reason_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::generate_content_response::UsageMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UsageMetadata");
        debug_struct.field("prompt_token_count", &self.prompt_token_count);
        debug_struct.field("candidates_token_count", &self.candidates_token_count);
        debug_struct.field("thoughts_token_count", &self.thoughts_token_count);
        debug_struct.field("total_token_count", &self.total_token_count);
        debug_struct.field(
            "cached_content_token_count",
            &self.cached_content_token_count,
        );
        debug_struct.field("prompt_tokens_details", &self.prompt_tokens_details);
        debug_struct.field("cache_tokens_details", &self.cache_tokens_details);
        debug_struct.field("candidates_tokens_details", &self.candidates_tokens_details);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::EmbedContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EmbedContentRequest");
        debug_struct.field("model", &self.model);
        debug_struct.field("content", &self.content);
        debug_struct.field("title", &self.title);
        debug_struct.field("task_type", &self.task_type);
        debug_struct.field("output_dimensionality", &self.output_dimensionality);
        debug_struct.field("auto_truncate", &self.auto_truncate);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::EmbedContentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EmbedContentResponse");
        debug_struct.field("embedding", &self.embedding);
        debug_struct.field("usage_metadata", &self.usage_metadata);
        debug_struct.field("truncated", &self.truncated);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::embed_content_response::Embedding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Embedding");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::PublisherModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PublisherModel");
        debug_struct.field("name", &self.name);
        debug_struct.field("version_id", &self.version_id);
        debug_struct.field("open_source_category", &self.open_source_category);
        debug_struct.field("supported_actions", &self.supported_actions);
        debug_struct.field("frameworks", &self.frameworks);
        debug_struct.field("launch_stage", &self.launch_stage);
        debug_struct.field("version_state", &self.version_state);
        debug_struct.field("publisher_model_template", &self.publisher_model_template);
        debug_struct.field("predict_schemata", &self.predict_schemata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::ResourceReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceReference");
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::Documentation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Documentation");
        debug_struct.field("title", &self.title);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::CallToAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CallToAction");
        debug_struct.field("view_rest_api", &self.view_rest_api);
        debug_struct.field("open_notebook", &self.open_notebook);
        debug_struct.field("open_notebooks", &self.open_notebooks);
        debug_struct.field("create_application", &self.create_application);
        debug_struct.field("open_fine_tuning_pipeline", &self.open_fine_tuning_pipeline);
        debug_struct.field(
            "open_fine_tuning_pipelines",
            &self.open_fine_tuning_pipelines,
        );
        debug_struct.field(
            "open_prompt_tuning_pipeline",
            &self.open_prompt_tuning_pipeline,
        );
        debug_struct.field("open_genie", &self.open_genie);
        debug_struct.field("deploy", &self.deploy);
        debug_struct.field("deploy_gke", &self.deploy_gke);
        debug_struct.field("open_generation_ai_studio", &self.open_generation_ai_studio);
        debug_struct.field("request_access", &self.request_access);
        debug_struct.field("open_evaluation_pipeline", &self.open_evaluation_pipeline);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::RegionalResourceReferences {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RegionalResourceReferences");
        debug_struct.field("references", &self.references);
        debug_struct.field("title", &self.title);
        debug_struct.field("resource_title", &self.resource_title);
        debug_struct.field("resource_use_case", &self.resource_use_case);
        debug_struct.field("resource_description", &self.resource_description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::ViewRestApi {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ViewRestApi");
        debug_struct.field("documentations", &self.documentations);
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::OpenNotebooks {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OpenNotebooks");
        debug_struct.field("notebooks", &self.notebooks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::OpenFineTuningPipelines {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OpenFineTuningPipelines");
        debug_struct.field("fine_tuning_pipelines", &self.fine_tuning_pipelines);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::Deploy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Deploy");
        debug_struct.field("model_display_name", &self.model_display_name);
        debug_struct.field("large_model_reference", &self.large_model_reference);
        debug_struct.field("container_spec", &self.container_spec);
        debug_struct.field("artifact_uri", &self.artifact_uri);
        debug_struct.field("deploy_task_name", &self.deploy_task_name);
        debug_struct.field("deploy_metadata", &self.deploy_metadata);
        debug_struct.field("title", &self.title);
        debug_struct.field("public_artifact_uri", &self.public_artifact_uri);
        debug_struct.field("prediction_resources", &self.prediction_resources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::deploy::DeployMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployMetadata");
        debug_struct.field("labels", &self.labels);
        debug_struct.field("sample_request", &self.sample_request);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "model-garden-service")]
impl std::fmt::Debug for super::publisher_model::call_to_action::DeployGke {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployGke");
        debug_struct.field("gke_yaml_configs", &self.gke_yaml_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::ReasoningEngineSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReasoningEngineSpec");
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("package_spec", &self.package_spec);
        debug_struct.field("deployment_spec", &self.deployment_spec);
        debug_struct.field("class_methods", &self.class_methods);
        debug_struct.field("agent_framework", &self.agent_framework);
        debug_struct.field("deployment_source", &self.deployment_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::PackageSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PackageSpec");
        debug_struct.field("pickle_object_gcs_uri", &self.pickle_object_gcs_uri);
        debug_struct.field("dependency_files_gcs_uri", &self.dependency_files_gcs_uri);
        debug_struct.field("requirements_gcs_uri", &self.requirements_gcs_uri);
        debug_struct.field("python_version", &self.python_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::DeploymentSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeploymentSpec");
        debug_struct.field("env", &self.env);
        debug_struct.field("secret_env", &self.secret_env);
        debug_struct.field("psc_interface_config", &self.psc_interface_config);
        debug_struct.field("min_instances", &self.min_instances);
        debug_struct.field("max_instances", &self.max_instances);
        debug_struct.field("resource_limits", &self.resource_limits);
        debug_struct.field("container_concurrency", &self.container_concurrency);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::SourceCodeSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SourceCodeSpec");
        debug_struct.field("source", &self.source);
        debug_struct.field("language_spec", &self.language_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::source_code_spec::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("source_archive", &self.source_archive);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::source_code_spec::DeveloperConnectConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeveloperConnectConfig");
        debug_struct.field("git_repository_link", &self.git_repository_link);
        debug_struct.field("dir", &self.dir);
        debug_struct.field("revision", &self.revision);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::source_code_spec::DeveloperConnectSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeveloperConnectSource");
        debug_struct.field("config", &self.config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::reasoning_engine_spec::source_code_spec::PythonSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PythonSpec");
        debug_struct.field("version", &self.version);
        debug_struct.field("entrypoint_module", &self.entrypoint_module);
        debug_struct.field("entrypoint_object", &self.entrypoint_object);
        debug_struct.field("requirements_file", &self.requirements_file);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::ReasoningEngine {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReasoningEngine");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("spec", &self.spec);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("labels", &self.labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-execution-service")]
impl std::fmt::Debug for super::QueryReasoningEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryReasoningEngineRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("input", &self.input);
        debug_struct.field("class_method", &self.class_method);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-execution-service")]
impl std::fmt::Debug for super::QueryReasoningEngineResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryReasoningEngineResponse");
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-execution-service")]
impl std::fmt::Debug for super::StreamQueryReasoningEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamQueryReasoningEngineRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("input", &self.input);
        debug_struct.field("class_method", &self.class_method);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::CreateReasoningEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateReasoningEngineRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("reasoning_engine", &self.reasoning_engine);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::CreateReasoningEngineOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateReasoningEngineOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::GetReasoningEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetReasoningEngineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::UpdateReasoningEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateReasoningEngineRequest");
        debug_struct.field("reasoning_engine", &self.reasoning_engine);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::UpdateReasoningEngineOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateReasoningEngineOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::ListReasoningEnginesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListReasoningEnginesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::ListReasoningEnginesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListReasoningEnginesResponse");
        debug_struct.field("reasoning_engines", &self.reasoning_engines);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "reasoning-engine-service")]
impl std::fmt::Debug for super::DeleteReasoningEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteReasoningEngineRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "index-endpoint-service",
    feature = "job-service",
    feature = "model-garden-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::ReservationAffinity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReservationAffinity");
        debug_struct.field("reservation_affinity_type", &self.reservation_affinity_type);
        debug_struct.field("key", &self.key);
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::SavedQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SavedQuery");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("annotation_filter", &self.annotation_filter);
        debug_struct.field("problem_type", &self.problem_type);
        debug_struct.field("annotation_spec_count", &self.annotation_spec_count);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("support_automl_training", &self.support_automl_training);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::Schedule {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Schedule");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("max_run_count", &self.max_run_count);
        debug_struct.field("started_run_count", &self.started_run_count);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("next_run_time", &self.next_run_time);
        debug_struct.field("last_pause_time", &self.last_pause_time);
        debug_struct.field("last_resume_time", &self.last_resume_time);
        debug_struct.field("max_concurrent_run_count", &self.max_concurrent_run_count);
        debug_struct.field("allow_queueing", &self.allow_queueing);
        debug_struct.field("catch_up", &self.catch_up);
        debug_struct.field(
            "last_scheduled_run_response",
            &self.last_scheduled_run_response,
        );
        debug_struct.field("time_specification", &self.time_specification);
        debug_struct.field("request", &self.request);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::schedule::RunResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RunResponse");
        debug_struct.field("scheduled_run_time", &self.scheduled_run_time);
        debug_struct.field("run_response", &self.run_response);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::CreateScheduleRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateScheduleRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("schedule", &self.schedule);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::GetScheduleRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetScheduleRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::ListSchedulesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSchedulesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::ListSchedulesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSchedulesResponse");
        debug_struct.field("schedules", &self.schedules);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::DeleteScheduleRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteScheduleRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::PauseScheduleRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PauseScheduleRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::ResumeScheduleRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResumeScheduleRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("catch_up", &self.catch_up);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schedule-service")]
impl std::fmt::Debug for super::UpdateScheduleRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateScheduleRequest");
        debug_struct.field("schedule", &self.schedule);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "endpoint-service",
    feature = "feature-online-store-admin-service",
    feature = "index-endpoint-service",
))]
impl std::fmt::Debug for super::PSCAutomationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PSCAutomationConfig");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("network", &self.network);
        debug_struct.field("ip_address", &self.ip_address);
        debug_struct.field("forwarding_rule", &self.forwarding_rule);
        debug_struct.field("state", &self.state);
        debug_struct.field("error_message", &self.error_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "endpoint-service",
    feature = "feature-online-store-admin-service",
    feature = "index-endpoint-service",
))]
impl std::fmt::Debug for super::PrivateServiceConnectConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PrivateServiceConnectConfig");
        debug_struct.field(
            "enable_private_service_connect",
            &self.enable_private_service_connect,
        );
        debug_struct.field("project_allowlist", &self.project_allowlist);
        debug_struct.field("psc_automation_configs", &self.psc_automation_configs);
        debug_struct.field("service_attachment", &self.service_attachment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "index-endpoint-service")]
impl std::fmt::Debug for super::PscAutomatedEndpoints {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PscAutomatedEndpoints");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("network", &self.network);
        debug_struct.field("match_address", &self.match_address);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "job-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::PscInterfaceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PscInterfaceConfig");
        debug_struct.field("network_attachment", &self.network_attachment);
        debug_struct.field("dns_peering_configs", &self.dns_peering_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "job-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
))]
impl std::fmt::Debug for super::DnsPeeringConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DnsPeeringConfig");
        debug_struct.field("domain", &self.domain);
        debug_struct.field("target_project", &self.target_project);
        debug_struct.field("target_network", &self.target_network);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::SpecialistPool {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpecialistPool");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("specialist_managers_count", &self.specialist_managers_count);
        debug_struct.field("specialist_manager_emails", &self.specialist_manager_emails);
        debug_struct.field(
            "pending_data_labeling_jobs",
            &self.pending_data_labeling_jobs,
        );
        debug_struct.field("specialist_worker_emails", &self.specialist_worker_emails);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::CreateSpecialistPoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSpecialistPoolRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("specialist_pool", &self.specialist_pool);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::CreateSpecialistPoolOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSpecialistPoolOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::GetSpecialistPoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetSpecialistPoolRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::ListSpecialistPoolsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSpecialistPoolsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::ListSpecialistPoolsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSpecialistPoolsResponse");
        debug_struct.field("specialist_pools", &self.specialist_pools);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::DeleteSpecialistPoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSpecialistPoolRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::UpdateSpecialistPoolRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateSpecialistPoolRequest");
        debug_struct.field("specialist_pool", &self.specialist_pool);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "specialist-pool-service")]
impl std::fmt::Debug for super::UpdateSpecialistPoolOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateSpecialistPoolOperationMetadata");
        debug_struct.field("specialist_pool", &self.specialist_pool);
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::Study {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Study");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("study_spec", &self.study_spec);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("inactive_reason", &self.inactive_reason);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::Trial {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Trial");
        debug_struct.field("name", &self.name);
        debug_struct.field("id", &self.id);
        debug_struct.field("state", &self.state);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("final_measurement", &self.final_measurement);
        debug_struct.field("measurements", &self.measurements);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("client_id", &self.client_id);
        debug_struct.field("infeasible_reason", &self.infeasible_reason);
        debug_struct.field("custom_job", &self.custom_job);
        debug_struct.field("web_access_uris", &self.web_access_uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::trial::Parameter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Parameter");
        debug_struct.field("parameter_id", &self.parameter_id);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::TrialContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrialContext");
        debug_struct.field("description", &self.description);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::StudyTimeConstraint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StudyTimeConstraint");
        debug_struct.field("constraint", &self.constraint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::StudySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StudySpec");
        debug_struct.field("metrics", &self.metrics);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("algorithm", &self.algorithm);
        debug_struct.field("observation_noise", &self.observation_noise);
        debug_struct.field(
            "measurement_selection_type",
            &self.measurement_selection_type,
        );
        debug_struct.field("study_stopping_config", &self.study_stopping_config);
        debug_struct.field("automated_stopping_spec", &self.automated_stopping_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::MetricSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MetricSpec");
        debug_struct.field("metric_id", &self.metric_id);
        debug_struct.field("goal", &self.goal);
        debug_struct.field("safety_config", &self.safety_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::metric_spec::SafetyMetricConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyMetricConfig");
        debug_struct.field("safety_threshold", &self.safety_threshold);
        debug_struct.field(
            "desired_min_safe_trials_fraction",
            &self.desired_min_safe_trials_fraction,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::ParameterSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ParameterSpec");
        debug_struct.field("parameter_id", &self.parameter_id);
        debug_struct.field("scale_type", &self.scale_type);
        debug_struct.field(
            "conditional_parameter_specs",
            &self.conditional_parameter_specs,
        );
        debug_struct.field("parameter_value_spec", &self.parameter_value_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::parameter_spec::DoubleValueSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DoubleValueSpec");
        debug_struct.field("min_value", &self.min_value);
        debug_struct.field("max_value", &self.max_value);
        debug_struct.field("default_value", &self.default_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::parameter_spec::IntegerValueSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IntegerValueSpec");
        debug_struct.field("min_value", &self.min_value);
        debug_struct.field("max_value", &self.max_value);
        debug_struct.field("default_value", &self.default_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::parameter_spec::CategoricalValueSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CategoricalValueSpec");
        debug_struct.field("values", &self.values);
        debug_struct.field("default_value", &self.default_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::parameter_spec::DiscreteValueSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DiscreteValueSpec");
        debug_struct.field("values", &self.values);
        debug_struct.field("default_value", &self.default_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::parameter_spec::ConditionalParameterSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConditionalParameterSpec");
        debug_struct.field("parameter_spec", &self.parameter_spec);
        debug_struct.field("parent_value_condition", &self.parent_value_condition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug
    for super::study_spec::parameter_spec::conditional_parameter_spec::DiscreteValueCondition
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DiscreteValueCondition");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug
    for super::study_spec::parameter_spec::conditional_parameter_spec::IntValueCondition
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IntValueCondition");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug
    for super::study_spec::parameter_spec::conditional_parameter_spec::CategoricalValueCondition
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CategoricalValueCondition");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::DecayCurveAutomatedStoppingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DecayCurveAutomatedStoppingSpec");
        debug_struct.field("use_elapsed_duration", &self.use_elapsed_duration);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::MedianAutomatedStoppingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MedianAutomatedStoppingSpec");
        debug_struct.field("use_elapsed_duration", &self.use_elapsed_duration);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::ConvexAutomatedStoppingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConvexAutomatedStoppingSpec");
        debug_struct.field("max_step_count", &self.max_step_count);
        debug_struct.field("min_step_count", &self.min_step_count);
        debug_struct.field("min_measurement_count", &self.min_measurement_count);
        debug_struct.field(
            "learning_rate_parameter_name",
            &self.learning_rate_parameter_name,
        );
        debug_struct.field("use_elapsed_duration", &self.use_elapsed_duration);
        debug_struct.field("update_all_stopped_trials", &self.update_all_stopped_trials);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::study_spec::StudyStoppingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StudyStoppingConfig");
        debug_struct.field("should_stop_asap", &self.should_stop_asap);
        debug_struct.field(
            "minimum_runtime_constraint",
            &self.minimum_runtime_constraint,
        );
        debug_struct.field(
            "maximum_runtime_constraint",
            &self.maximum_runtime_constraint,
        );
        debug_struct.field("min_num_trials", &self.min_num_trials);
        debug_struct.field("max_num_trials", &self.max_num_trials);
        debug_struct.field(
            "max_num_trials_no_progress",
            &self.max_num_trials_no_progress,
        );
        debug_struct.field("max_duration_no_progress", &self.max_duration_no_progress);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::Measurement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Measurement");
        debug_struct.field("elapsed_duration", &self.elapsed_duration);
        debug_struct.field("step_count", &self.step_count);
        debug_struct.field("metrics", &self.metrics);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "job-service", feature = "vizier-service",))]
impl std::fmt::Debug for super::measurement::Metric {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Metric");
        debug_struct.field("metric_id", &self.metric_id);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::Tensorboard {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tensorboard");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("blob_storage_path_prefix", &self.blob_storage_path_prefix);
        debug_struct.field("run_count", &self.run_count);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("is_default", &self.is_default);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TimeSeriesData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TimeSeriesData");
        debug_struct.field(
            "tensorboard_time_series_id",
            &self.tensorboard_time_series_id,
        );
        debug_struct.field("value_type", &self.value_type);
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TimeSeriesDataPoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TimeSeriesDataPoint");
        debug_struct.field("wall_time", &self.wall_time);
        debug_struct.field("step", &self.step);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::Scalar {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Scalar");
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TensorboardTensor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TensorboardTensor");
        debug_struct.field("value", &self.value);
        debug_struct.field("version_number", &self.version_number);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TensorboardBlobSequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TensorboardBlobSequence");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TensorboardBlob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TensorboardBlob");
        debug_struct.field("id", &self.id);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TensorboardExperiment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TensorboardExperiment");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TensorboardRun {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TensorboardRun");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("etag", &self.etag);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::CreateTensorboardRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTensorboardRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("tensorboard", &self.tensorboard);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::GetTensorboardRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTensorboardRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardsResponse");
        debug_struct.field("tensorboards", &self.tensorboards);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::UpdateTensorboardRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTensorboardRequest");
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("tensorboard", &self.tensorboard);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::DeleteTensorboardRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTensorboardRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardUsageRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardUsageRequest");
        debug_struct.field("tensorboard", &self.tensorboard);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardUsageResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardUsageResponse");
        debug_struct.field("monthly_usage_data", &self.monthly_usage_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::read_tensorboard_usage_response::PerUserUsageData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PerUserUsageData");
        debug_struct.field("username", &self.username);
        debug_struct.field("view_count", &self.view_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::read_tensorboard_usage_response::PerMonthUsageData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PerMonthUsageData");
        debug_struct.field("user_usage_data", &self.user_usage_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardSizeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardSizeRequest");
        debug_struct.field("tensorboard", &self.tensorboard);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardSizeResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardSizeResponse");
        debug_struct.field("storage_size_byte", &self.storage_size_byte);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::CreateTensorboardExperimentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTensorboardExperimentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("tensorboard_experiment", &self.tensorboard_experiment);
        debug_struct.field("tensorboard_experiment_id", &self.tensorboard_experiment_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::GetTensorboardExperimentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTensorboardExperimentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardExperimentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardExperimentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardExperimentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardExperimentsResponse");
        debug_struct.field("tensorboard_experiments", &self.tensorboard_experiments);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::UpdateTensorboardExperimentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTensorboardExperimentRequest");
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("tensorboard_experiment", &self.tensorboard_experiment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::DeleteTensorboardExperimentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTensorboardExperimentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::BatchCreateTensorboardRunsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTensorboardRunsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("requests", &self.requests);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::BatchCreateTensorboardRunsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTensorboardRunsResponse");
        debug_struct.field("tensorboard_runs", &self.tensorboard_runs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::CreateTensorboardRunRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTensorboardRunRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("tensorboard_run", &self.tensorboard_run);
        debug_struct.field("tensorboard_run_id", &self.tensorboard_run_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::GetTensorboardRunRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTensorboardRunRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardBlobDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardBlobDataRequest");
        debug_struct.field("time_series", &self.time_series);
        debug_struct.field("blob_ids", &self.blob_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardBlobDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardBlobDataResponse");
        debug_struct.field("blobs", &self.blobs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardRunsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardRunsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardRunsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardRunsResponse");
        debug_struct.field("tensorboard_runs", &self.tensorboard_runs);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::UpdateTensorboardRunRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTensorboardRunRequest");
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("tensorboard_run", &self.tensorboard_run);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::DeleteTensorboardRunRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTensorboardRunRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::BatchCreateTensorboardTimeSeriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTensorboardTimeSeriesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("requests", &self.requests);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::BatchCreateTensorboardTimeSeriesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTensorboardTimeSeriesResponse");
        debug_struct.field("tensorboard_time_series", &self.tensorboard_time_series);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::CreateTensorboardTimeSeriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTensorboardTimeSeriesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field(
            "tensorboard_time_series_id",
            &self.tensorboard_time_series_id,
        );
        debug_struct.field("tensorboard_time_series", &self.tensorboard_time_series);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::GetTensorboardTimeSeriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTensorboardTimeSeriesRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardTimeSeriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardTimeSeriesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("read_mask", &self.read_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ListTensorboardTimeSeriesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTensorboardTimeSeriesResponse");
        debug_struct.field("tensorboard_time_series", &self.tensorboard_time_series);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::UpdateTensorboardTimeSeriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTensorboardTimeSeriesRequest");
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("tensorboard_time_series", &self.tensorboard_time_series);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::DeleteTensorboardTimeSeriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTensorboardTimeSeriesRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::BatchReadTensorboardTimeSeriesDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchReadTensorboardTimeSeriesDataRequest");
        debug_struct.field("tensorboard", &self.tensorboard);
        debug_struct.field("time_series", &self.time_series);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::BatchReadTensorboardTimeSeriesDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchReadTensorboardTimeSeriesDataResponse");
        debug_struct.field("time_series_data", &self.time_series_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardTimeSeriesDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardTimeSeriesDataRequest");
        debug_struct.field("tensorboard_time_series", &self.tensorboard_time_series);
        debug_struct.field("max_data_points", &self.max_data_points);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ReadTensorboardTimeSeriesDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadTensorboardTimeSeriesDataResponse");
        debug_struct.field("time_series_data", &self.time_series_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::WriteTensorboardExperimentDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteTensorboardExperimentDataRequest");
        debug_struct.field("tensorboard_experiment", &self.tensorboard_experiment);
        debug_struct.field("write_run_data_requests", &self.write_run_data_requests);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::WriteTensorboardExperimentDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteTensorboardExperimentDataResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::WriteTensorboardRunDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteTensorboardRunDataRequest");
        debug_struct.field("tensorboard_run", &self.tensorboard_run);
        debug_struct.field("time_series_data", &self.time_series_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::WriteTensorboardRunDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteTensorboardRunDataResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ExportTensorboardTimeSeriesDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportTensorboardTimeSeriesDataRequest");
        debug_struct.field("tensorboard_time_series", &self.tensorboard_time_series);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::ExportTensorboardTimeSeriesDataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportTensorboardTimeSeriesDataResponse");
        debug_struct.field("time_series_data_points", &self.time_series_data_points);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::CreateTensorboardOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTensorboardOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::UpdateTensorboardOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTensorboardOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::TensorboardTimeSeries {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TensorboardTimeSeries");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("value_type", &self.value_type);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("etag", &self.etag);
        debug_struct.field("plugin_name", &self.plugin_name);
        debug_struct.field("plugin_data", &self.plugin_data);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "tensorboard-service")]
impl std::fmt::Debug for super::tensorboard_time_series::Metadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Metadata");
        debug_struct.field("max_step", &self.max_step);
        debug_struct.field("max_wall_time", &self.max_wall_time);
        debug_struct.field("max_blob_sequence_length", &self.max_blob_sequence_length);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::Tool {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tool");
        debug_struct.field("function_declarations", &self.function_declarations);
        debug_struct.field("retrieval", &self.retrieval);
        debug_struct.field("google_search", &self.google_search);
        debug_struct.field("google_search_retrieval", &self.google_search_retrieval);
        debug_struct.field("google_maps", &self.google_maps);
        debug_struct.field("enterprise_web_search", &self.enterprise_web_search);
        debug_struct.field("code_execution", &self.code_execution);
        debug_struct.field("url_context", &self.url_context);
        debug_struct.field("computer_use", &self.computer_use);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::tool::GoogleSearch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GoogleSearch");
        debug_struct.field("exclude_domains", &self.exclude_domains);
        debug_struct.field("blocking_confidence", &self.blocking_confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::tool::CodeExecution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CodeExecution");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::tool::ComputerUse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ComputerUse");
        debug_struct.field("environment", &self.environment);
        debug_struct.field(
            "excluded_predefined_functions",
            &self.excluded_predefined_functions,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::UrlContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UrlContext");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::FunctionDeclaration {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionDeclaration");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("parameters_json_schema", &self.parameters_json_schema);
        debug_struct.field("response", &self.response);
        debug_struct.field("response_json_schema", &self.response_json_schema);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::FunctionCall {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionCall");
        debug_struct.field("name", &self.name);
        debug_struct.field("args", &self.args);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::FunctionResponsePart {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionResponsePart");
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::FunctionResponseBlob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionResponseBlob");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("data", &self.data);
        debug_struct.field("display_name", &self.display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::FunctionResponseFileData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionResponseFileData");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("file_uri", &self.file_uri);
        debug_struct.field("display_name", &self.display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::FunctionResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionResponse");
        debug_struct.field("name", &self.name);
        debug_struct.field("response", &self.response);
        debug_struct.field("parts", &self.parts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::ExecutableCode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExecutableCode");
        debug_struct.field("language", &self.language);
        debug_struct.field("code", &self.code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "data-foundry-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::CodeExecutionResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CodeExecutionResult");
        debug_struct.field("outcome", &self.outcome);
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::Retrieval {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Retrieval");
        debug_struct.field("disable_attribution", &self.disable_attribution);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::VertexRagStore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexRagStore");
        debug_struct.field("rag_resources", &self.rag_resources);
        debug_struct.field("similarity_top_k", &self.similarity_top_k);
        debug_struct.field("vector_distance_threshold", &self.vector_distance_threshold);
        debug_struct.field("rag_retrieval_config", &self.rag_retrieval_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::vertex_rag_store::RagResource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagResource");
        debug_struct.field("rag_corpus", &self.rag_corpus);
        debug_struct.field("rag_file_ids", &self.rag_file_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::VertexAISearch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexAISearch");
        debug_struct.field("datastore", &self.datastore);
        debug_struct.field("engine", &self.engine);
        debug_struct.field("max_results", &self.max_results);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("data_store_specs", &self.data_store_specs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::vertex_ai_search::DataStoreSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataStoreSpec");
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::GoogleSearchRetrieval {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GoogleSearchRetrieval");
        debug_struct.field("dynamic_retrieval_config", &self.dynamic_retrieval_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::GoogleMaps {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GoogleMaps");
        debug_struct.field("enable_widget", &self.enable_widget);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::EnterpriseWebSearch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnterpriseWebSearch");
        debug_struct.field("exclude_domains", &self.exclude_domains);
        debug_struct.field("blocking_confidence", &self.blocking_confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
))]
impl std::fmt::Debug for super::DynamicRetrievalConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DynamicRetrievalConfig");
        debug_struct.field("mode", &self.mode);
        debug_struct.field("dynamic_threshold", &self.dynamic_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "gen-ai-cache-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::ToolConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolConfig");
        debug_struct.field("function_calling_config", &self.function_calling_config);
        debug_struct.field("retrieval_config", &self.retrieval_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "gen-ai-cache-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::FunctionCallingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FunctionCallingConfig");
        debug_struct.field("mode", &self.mode);
        debug_struct.field("allowed_function_names", &self.allowed_function_names);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "gen-ai-cache-service", feature = "prediction-service",))]
impl std::fmt::Debug for super::RetrievalConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RetrievalConfig");
        debug_struct.field("lat_lng", &self.lat_lng);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::RagRetrievalConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagRetrievalConfig");
        debug_struct.field("top_k", &self.top_k);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("ranking", &self.ranking);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::rag_retrieval_config::Filter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Filter");
        debug_struct.field("metadata_filter", &self.metadata_filter);
        debug_struct.field("vector_db_threshold", &self.vector_db_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::rag_retrieval_config::Ranking {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Ranking");
        debug_struct.field("ranking_config", &self.ranking_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::rag_retrieval_config::ranking::RankService {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RankService");
        debug_struct.field("model_name", &self.model_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "gen-ai-cache-service",
    feature = "llm-utility-service",
    feature = "prediction-service",
    feature = "vertex-rag-service",
))]
impl std::fmt::Debug for super::rag_retrieval_config::ranking::LlmRanker {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LlmRanker");
        debug_struct.field("model_name", &self.model_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::TrainingPipeline {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainingPipeline");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("input_data_config", &self.input_data_config);
        debug_struct.field("training_task_definition", &self.training_task_definition);
        debug_struct.field("training_task_inputs", &self.training_task_inputs);
        debug_struct.field("training_task_metadata", &self.training_task_metadata);
        debug_struct.field("model_to_upload", &self.model_to_upload);
        debug_struct.field("model_id", &self.model_id);
        debug_struct.field("parent_model", &self.parent_model);
        debug_struct.field("state", &self.state);
        debug_struct.field("error", &self.error);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::InputDataConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputDataConfig");
        debug_struct.field("dataset_id", &self.dataset_id);
        debug_struct.field("annotations_filter", &self.annotations_filter);
        debug_struct.field("annotation_schema_uri", &self.annotation_schema_uri);
        debug_struct.field("saved_query_id", &self.saved_query_id);
        debug_struct.field("persist_ml_use_assignment", &self.persist_ml_use_assignment);
        debug_struct.field("split", &self.split);
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::FractionSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FractionSplit");
        debug_struct.field("training_fraction", &self.training_fraction);
        debug_struct.field("validation_fraction", &self.validation_fraction);
        debug_struct.field("test_fraction", &self.test_fraction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::FilterSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FilterSplit");
        debug_struct.field("training_filter", &self.training_filter);
        debug_struct.field("validation_filter", &self.validation_filter);
        debug_struct.field("test_filter", &self.test_filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::PredefinedSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PredefinedSplit");
        debug_struct.field("key", &self.key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::TimestampSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TimestampSplit");
        debug_struct.field("training_fraction", &self.training_fraction);
        debug_struct.field("validation_fraction", &self.validation_fraction);
        debug_struct.field("test_fraction", &self.test_fraction);
        debug_struct.field("key", &self.key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "pipeline-service")]
impl std::fmt::Debug for super::StratifiedSplit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StratifiedSplit");
        debug_struct.field("training_fraction", &self.training_fraction);
        debug_struct.field("validation_fraction", &self.validation_fraction);
        debug_struct.field("test_fraction", &self.test_fraction);
        debug_struct.field("key", &self.key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::TuningJob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TuningJob");
        debug_struct.field("name", &self.name);
        debug_struct.field("tuned_model_display_name", &self.tuned_model_display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("error", &self.error);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("experiment", &self.experiment);
        debug_struct.field("tuned_model", &self.tuned_model);
        debug_struct.field("tuning_data_stats", &self.tuning_data_stats);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field("source_model", &self.source_model);
        debug_struct.field("tuning_spec", &self.tuning_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::TunedModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TunedModel");
        debug_struct.field("model", &self.model);
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("checkpoints", &self.checkpoints);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::SupervisedTuningDatasetDistribution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SupervisedTuningDatasetDistribution");
        debug_struct.field("sum", &self.sum);
        debug_struct.field("billable_sum", &self.billable_sum);
        debug_struct.field("min", &self.min);
        debug_struct.field("max", &self.max);
        debug_struct.field("mean", &self.mean);
        debug_struct.field("median", &self.median);
        debug_struct.field("p5", &self.p5);
        debug_struct.field("p95", &self.p95);
        debug_struct.field("buckets", &self.buckets);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::supervised_tuning_dataset_distribution::DatasetBucket {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DatasetBucket");
        debug_struct.field("count", &self.count);
        debug_struct.field("left", &self.left);
        debug_struct.field("right", &self.right);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::SupervisedTuningDataStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SupervisedTuningDataStats");
        debug_struct.field(
            "tuning_dataset_example_count",
            &self.tuning_dataset_example_count,
        );
        debug_struct.field(
            "total_tuning_character_count",
            &self.total_tuning_character_count,
        );
        debug_struct.field(
            "total_billable_character_count",
            &self.total_billable_character_count,
        );
        debug_struct.field(
            "total_billable_token_count",
            &self.total_billable_token_count,
        );
        debug_struct.field("tuning_step_count", &self.tuning_step_count);
        debug_struct.field(
            "user_input_token_distribution",
            &self.user_input_token_distribution,
        );
        debug_struct.field(
            "user_output_token_distribution",
            &self.user_output_token_distribution,
        );
        debug_struct.field(
            "user_message_per_example_distribution",
            &self.user_message_per_example_distribution,
        );
        debug_struct.field("user_dataset_examples", &self.user_dataset_examples);
        debug_struct.field(
            "total_truncated_example_count",
            &self.total_truncated_example_count,
        );
        debug_struct.field("truncated_example_indices", &self.truncated_example_indices);
        debug_struct.field("dropped_example_reasons", &self.dropped_example_reasons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::TuningDataStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TuningDataStats");
        debug_struct.field("tuning_data_stats", &self.tuning_data_stats);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::SupervisedHyperParameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SupervisedHyperParameters");
        debug_struct.field("epoch_count", &self.epoch_count);
        debug_struct.field("learning_rate_multiplier", &self.learning_rate_multiplier);
        debug_struct.field("adapter_size", &self.adapter_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::SupervisedTuningSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SupervisedTuningSpec");
        debug_struct.field("training_dataset_uri", &self.training_dataset_uri);
        debug_struct.field("validation_dataset_uri", &self.validation_dataset_uri);
        debug_struct.field("hyper_parameters", &self.hyper_parameters);
        debug_struct.field(
            "export_last_checkpoint_only",
            &self.export_last_checkpoint_only,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::TunedModelRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TunedModelRef");
        debug_struct.field("tuned_model_ref", &self.tuned_model_ref);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::TunedModelCheckpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TunedModelCheckpoint");
        debug_struct.field("checkpoint_id", &self.checkpoint_id);
        debug_struct.field("epoch", &self.epoch);
        debug_struct.field("step", &self.step);
        debug_struct.field("endpoint", &self.endpoint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "gen-ai-tuning-service")]
impl std::fmt::Debug for super::PreTunedModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PreTunedModel");
        debug_struct.field("tuned_model_name", &self.tuned_model_name);
        debug_struct.field("checkpoint_id", &self.checkpoint_id);
        debug_struct.field("base_model", &self.base_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::BoolArray {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoolArray");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::DoubleArray {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DoubleArray");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::Int64Array {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Int64Array");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "feature-online-store-service",
    feature = "featurestore-online-serving-service",
))]
impl std::fmt::Debug for super::StringArray {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StringArray");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::Tensor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tensor");
        debug_struct.field("dtype", &self.dtype);
        debug_struct.field("shape", &self.shape);
        debug_struct.field("bool_val", &self.bool_val);
        debug_struct.field("string_val", &self.string_val);
        debug_struct.field("bytes_val", &self.bytes_val);
        debug_struct.field("float_val", &self.float_val);
        debug_struct.field("double_val", &self.double_val);
        debug_struct.field("int_val", &self.int_val);
        debug_struct.field("int64_val", &self.int64_val);
        debug_struct.field("uint_val", &self.uint_val);
        debug_struct.field("uint64_val", &self.uint64_val);
        debug_struct.field("list_val", &self.list_val);
        debug_struct.field("struct_val", &self.struct_val);
        debug_struct.field("tensor_val", &self.tensor_val);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "job-service")]
impl std::fmt::Debug for super::UnmanagedContainerModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UnmanagedContainerModel");
        debug_struct.field("artifact_uri", &self.artifact_uri);
        debug_struct.field("predict_schemata", &self.predict_schemata);
        debug_struct.field("container_spec", &self.container_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "prediction-service")]
impl std::fmt::Debug for super::UsageMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UsageMetadata");
        debug_struct.field("prompt_token_count", &self.prompt_token_count);
        debug_struct.field("candidates_token_count", &self.candidates_token_count);
        debug_struct.field("total_token_count", &self.total_token_count);
        debug_struct.field(
            "tool_use_prompt_token_count",
            &self.tool_use_prompt_token_count,
        );
        debug_struct.field("thoughts_token_count", &self.thoughts_token_count);
        debug_struct.field(
            "cached_content_token_count",
            &self.cached_content_token_count,
        );
        debug_struct.field("prompt_tokens_details", &self.prompt_tokens_details);
        debug_struct.field("cache_tokens_details", &self.cache_tokens_details);
        debug_struct.field("candidates_tokens_details", &self.candidates_tokens_details);
        debug_struct.field(
            "tool_use_prompt_tokens_details",
            &self.tool_use_prompt_tokens_details,
        );
        debug_struct.field("traffic_type", &self.traffic_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "dataset-service")]
impl std::fmt::Debug for super::UserActionReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UserActionReference");
        debug_struct.field("method", &self.method);
        debug_struct.field("reference", &self.reference);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "pipeline-service", feature = "schedule-service",))]
impl std::fmt::Debug for super::Value {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Value");
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagEmbeddingModelConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagEmbeddingModelConfig");
        debug_struct.field("model_config", &self.model_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_embedding_model_config::VertexPredictionEndpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexPredictionEndpoint");
        debug_struct.field("endpoint", &self.endpoint);
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version_id", &self.model_version_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagVectorDbConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagVectorDbConfig");
        debug_struct.field("api_auth", &self.api_auth);
        debug_struct.field(
            "rag_embedding_model_config",
            &self.rag_embedding_model_config,
        );
        debug_struct.field("vector_db", &self.vector_db);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_vector_db_config::RagManagedDb {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagManagedDb");
        debug_struct.field("retrieval_strategy", &self.retrieval_strategy);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_vector_db_config::rag_managed_db::Knn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Knn");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_vector_db_config::rag_managed_db::Ann {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Ann");
        debug_struct.field("tree_depth", &self.tree_depth);
        debug_struct.field("leaf_count", &self.leaf_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_vector_db_config::Pinecone {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Pinecone");
        debug_struct.field("index_name", &self.index_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_vector_db_config::VertexVectorSearch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexVectorSearch");
        debug_struct.field("index_endpoint", &self.index_endpoint);
        debug_struct.field("index", &self.index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::FileStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileStatus");
        debug_struct.field("state", &self.state);
        debug_struct.field("error_status", &self.error_status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::VertexAiSearchConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexAiSearchConfig");
        debug_struct.field("serving_config", &self.serving_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::CorpusStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CorpusStatus");
        debug_struct.field("state", &self.state);
        debug_struct.field("error_status", &self.error_status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagCorpus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagCorpus");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("corpus_status", &self.corpus_status);
        debug_struct.field("encryption_spec", &self.encryption_spec);
        debug_struct.field("backend_config", &self.backend_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagFile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagFile");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("file_status", &self.file_status);
        debug_struct.field("rag_file_source", &self.rag_file_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "prediction-service", feature = "vertex-rag-service",))]
impl std::fmt::Debug for super::RagChunk {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagChunk");
        debug_struct.field("text", &self.text);
        debug_struct.field("page_span", &self.page_span);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "prediction-service", feature = "vertex-rag-service",))]
impl std::fmt::Debug for super::rag_chunk::PageSpan {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PageSpan");
        debug_struct.field("first_page", &self.first_page);
        debug_struct.field("last_page", &self.last_page);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagFileChunkingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagFileChunkingConfig");
        debug_struct.field("chunking_config", &self.chunking_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_file_chunking_config::FixedLengthChunking {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FixedLengthChunking");
        debug_struct.field("chunk_size", &self.chunk_size);
        debug_struct.field("chunk_overlap", &self.chunk_overlap);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagFileTransformationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagFileTransformationConfig");
        debug_struct.field("rag_file_chunking_config", &self.rag_file_chunking_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagFileParsingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagFileParsingConfig");
        debug_struct.field("parser", &self.parser);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_file_parsing_config::LayoutParser {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LayoutParser");
        debug_struct.field("processor_name", &self.processor_name);
        debug_struct.field(
            "max_parsing_requests_per_min",
            &self.max_parsing_requests_per_min,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_file_parsing_config::LlmParser {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LlmParser");
        debug_struct.field("model_name", &self.model_name);
        debug_struct.field(
            "max_parsing_requests_per_min",
            &self.max_parsing_requests_per_min,
        );
        debug_struct.field("custom_parsing_prompt", &self.custom_parsing_prompt);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UploadRagFileConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UploadRagFileConfig");
        debug_struct.field(
            "rag_file_transformation_config",
            &self.rag_file_transformation_config,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ImportRagFilesConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportRagFilesConfig");
        debug_struct.field(
            "rag_file_transformation_config",
            &self.rag_file_transformation_config,
        );
        debug_struct.field("rag_file_parsing_config", &self.rag_file_parsing_config);
        debug_struct.field(
            "max_embedding_requests_per_min",
            &self.max_embedding_requests_per_min,
        );
        debug_struct.field("rebuild_ann_index", &self.rebuild_ann_index);
        debug_struct.field("import_source", &self.import_source);
        debug_struct.field("partial_failure_sink", &self.partial_failure_sink);
        debug_struct.field("import_result_sink", &self.import_result_sink);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagManagedDbConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagManagedDbConfig");
        debug_struct.field("tier", &self.tier);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_managed_db_config::Scaled {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Scaled");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_managed_db_config::Basic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Basic");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::rag_managed_db_config::Unprovisioned {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Unprovisioned");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::RagEngineConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagEngineConfig");
        debug_struct.field("name", &self.name);
        debug_struct.field("rag_managed_db_config", &self.rag_managed_db_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::CreateRagCorpusRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateRagCorpusRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("rag_corpus", &self.rag_corpus);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::GetRagCorpusRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetRagCorpusRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ListRagCorporaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListRagCorporaRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ListRagCorporaResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListRagCorporaResponse");
        debug_struct.field("rag_corpora", &self.rag_corpora);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::DeleteRagCorpusRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteRagCorpusRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UploadRagFileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UploadRagFileRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("rag_file", &self.rag_file);
        debug_struct.field("upload_rag_file_config", &self.upload_rag_file_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UploadRagFileResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UploadRagFileResponse");
        debug_struct.field("result", &self.result);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ImportRagFilesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportRagFilesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("import_rag_files_config", &self.import_rag_files_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ImportRagFilesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportRagFilesResponse");
        debug_struct.field("imported_rag_files_count", &self.imported_rag_files_count);
        debug_struct.field("failed_rag_files_count", &self.failed_rag_files_count);
        debug_struct.field("skipped_rag_files_count", &self.skipped_rag_files_count);
        debug_struct.field("partial_failure_sink", &self.partial_failure_sink);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::GetRagFileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetRagFileRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ListRagFilesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListRagFilesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ListRagFilesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListRagFilesResponse");
        debug_struct.field("rag_files", &self.rag_files);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::DeleteRagFileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteRagFileRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::CreateRagCorpusOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateRagCorpusOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::GetRagEngineConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetRagEngineConfigRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UpdateRagCorpusRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateRagCorpusRequest");
        debug_struct.field("rag_corpus", &self.rag_corpus);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UpdateRagCorpusOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateRagCorpusOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::ImportRagFilesOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportRagFilesOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("rag_corpus_id", &self.rag_corpus_id);
        debug_struct.field("import_rag_files_config", &self.import_rag_files_config);
        debug_struct.field("progress_percentage", &self.progress_percentage);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UpdateRagEngineConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateRagEngineConfigRequest");
        debug_struct.field("rag_engine_config", &self.rag_engine_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-data-service")]
impl std::fmt::Debug for super::UpdateRagEngineConfigOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateRagEngineConfigOperationMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::RagQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagQuery");
        debug_struct.field("rag_retrieval_config", &self.rag_retrieval_config);
        debug_struct.field("query", &self.query);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::RetrieveContextsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RetrieveContextsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("query", &self.query);
        debug_struct.field("data_source", &self.data_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::retrieve_contexts_request::VertexRagStore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexRagStore");
        debug_struct.field("rag_resources", &self.rag_resources);
        debug_struct.field("vector_distance_threshold", &self.vector_distance_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::retrieve_contexts_request::vertex_rag_store::RagResource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagResource");
        debug_struct.field("rag_corpus", &self.rag_corpus);
        debug_struct.field("rag_file_ids", &self.rag_file_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::RagContexts {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RagContexts");
        debug_struct.field("contexts", &self.contexts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::rag_contexts::Context {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Context");
        debug_struct.field("source_uri", &self.source_uri);
        debug_struct.field("source_display_name", &self.source_display_name);
        debug_struct.field("text", &self.text);
        debug_struct.field("score", &self.score);
        debug_struct.field("chunk", &self.chunk);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::RetrieveContextsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RetrieveContextsResponse");
        debug_struct.field("contexts", &self.contexts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::AugmentPromptRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AugmentPromptRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("contents", &self.contents);
        debug_struct.field("model", &self.model);
        debug_struct.field("data_source", &self.data_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::augment_prompt_request::Model {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Model");
        debug_struct.field("model", &self.model);
        debug_struct.field("model_version", &self.model_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::AugmentPromptResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AugmentPromptResponse");
        debug_struct.field("augmented_prompt", &self.augmented_prompt);
        debug_struct.field("facts", &self.facts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::CorroborateContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CorroborateContentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("content", &self.content);
        debug_struct.field("facts", &self.facts);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::corroborate_content_request::Parameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Parameters");
        debug_struct.field("citation_threshold", &self.citation_threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::CorroborateContentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CorroborateContentResponse");
        debug_struct.field("corroboration_score", &self.corroboration_score);
        debug_struct.field("claims", &self.claims);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::Fact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Fact");
        debug_struct.field("query", &self.query);
        debug_struct.field("title", &self.title);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("summary", &self.summary);
        debug_struct.field("vector_distance", &self.vector_distance);
        debug_struct.field("score", &self.score);
        debug_struct.field("chunk", &self.chunk);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vertex-rag-service")]
impl std::fmt::Debug for super::Claim {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Claim");
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("fact_indexes", &self.fact_indexes);
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::GetStudyRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetStudyRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::CreateStudyRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateStudyRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("study", &self.study);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::ListStudiesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListStudiesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("page_size", &self.page_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::ListStudiesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListStudiesResponse");
        debug_struct.field("studies", &self.studies);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::DeleteStudyRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteStudyRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::LookupStudyRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LookupStudyRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("display_name", &self.display_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::SuggestTrialsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestTrialsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("suggestion_count", &self.suggestion_count);
        debug_struct.field("client_id", &self.client_id);
        debug_struct.field("contexts", &self.contexts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::SuggestTrialsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestTrialsResponse");
        debug_struct.field("trials", &self.trials);
        debug_struct.field("study_state", &self.study_state);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::SuggestTrialsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestTrialsMetadata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("client_id", &self.client_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::CreateTrialRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTrialRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("trial", &self.trial);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::GetTrialRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTrialRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::ListTrialsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTrialsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("page_size", &self.page_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::ListTrialsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTrialsResponse");
        debug_struct.field("trials", &self.trials);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::AddTrialMeasurementRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AddTrialMeasurementRequest");
        debug_struct.field("trial_name", &self.trial_name);
        debug_struct.field("measurement", &self.measurement);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::CompleteTrialRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompleteTrialRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("final_measurement", &self.final_measurement);
        debug_struct.field("trial_infeasible", &self.trial_infeasible);
        debug_struct.field("infeasible_reason", &self.infeasible_reason);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::DeleteTrialRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTrialRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::CheckTrialEarlyStoppingStateRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckTrialEarlyStoppingStateRequest");
        debug_struct.field("trial_name", &self.trial_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::CheckTrialEarlyStoppingStateResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckTrialEarlyStoppingStateResponse");
        debug_struct.field("should_stop", &self.should_stop);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::CheckTrialEarlyStoppingStateMetatdata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckTrialEarlyStoppingStateMetatdata");
        debug_struct.field("generic_metadata", &self.generic_metadata);
        debug_struct.field("study", &self.study);
        debug_struct.field("trial", &self.trial);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::StopTrialRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StopTrialRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::ListOptimalTrialsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListOptimalTrialsRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "vizier-service")]
impl std::fmt::Debug for super::ListOptimalTrialsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListOptimalTrialsResponse");
        debug_struct.field("optimal_trials", &self.optimal_trials);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}
